/* This file is auto-generated, do not edit. */
#include "capi_thunks_autogen.h"

void test_capi_thunks_IVRSystem_022(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_022_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_022_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_022_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetProjectionMatrix, 4, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_022_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_022_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_022_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_022_GetProjectionMatrix", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_022_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_022_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_022_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_022_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_022_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_022_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_022_ComputeDistortion, 4, TRUE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
    check_ptr_parameter("IVRSystem_022_ComputeDistortion", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_022_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_022_ComputeDistortion", 3.0f);
    check_ptr_parameter("IVRSystem_022_ComputeDistortion", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_022_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_022_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_022_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_022_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_022_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_022_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetDXGIOutputInfo, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_022_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetDXGIOutputInfo((void *)1);
    check_ptr_parameter("IVRSystem_022_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetDXGIOutputInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetOutputDevice, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_022_GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetOutputDevice((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_022_GetOutputDevice", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetOutputDevice", (void *)1);
    check_uint32_parameter("IVRSystem_022_GetOutputDevice", 2);
    check_ptr_parameter("IVRSystem_022_GetOutputDevice", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_022_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_022_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_022_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_022_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_022_SetDisplayVisibility", 1);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_022_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_022_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_022_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_022_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_022_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_022_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_022_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_022_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_022_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_022_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_022_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_022_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_022_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_022_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_022_ApplyTransform, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_022_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_ApplyTransform((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_022_ApplyTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_ApplyTransform", (void *)1);
    check_ptr_parameter("IVRSystem_022_ApplyTransform", (void *)2);
    check_ptr_parameter("IVRSystem_022_ApplyTransform", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_022_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetTrackedDeviceIndexForControllerRole(1);
    check_ptr_parameter("IVRSystem_022_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetTrackedDeviceIndexForControllerRole", 1);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
    ETrackedControllerRole (__stdcall *capi_IVRSystem_022_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetControllerRoleForTrackedDeviceIndex(1);
    check_ptr_parameter("IVRSystem_022_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetControllerRoleForTrackedDeviceIndex", 1);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetTrackedDeviceClass, 1, FALSE, FALSE);
    ETrackedDeviceClass (__stdcall *capi_IVRSystem_022_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_022_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_022_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_022_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_022_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_022_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_022_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_022_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_022_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_022_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_022_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_022_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_022_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_022_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_022_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_022_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_022_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_022_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_022_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_022_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_022_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_022_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_022_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetArrayTrackedDeviceProperty, 6, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_022_GetArrayTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetArrayTrackedDeviceProperty(1, 2, 3, (void *)4, 5, (void *)6);
    check_ptr_parameter("IVRSystem_022_GetArrayTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetArrayTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_022_GetArrayTrackedDeviceProperty", 2);
    check_uint32_parameter("IVRSystem_022_GetArrayTrackedDeviceProperty", 3);
    check_ptr_parameter("IVRSystem_022_GetArrayTrackedDeviceProperty", (void *)4);
    check_uint32_parameter("IVRSystem_022_GetArrayTrackedDeviceProperty", 5);
    check_ptr_parameter("IVRSystem_022_GetArrayTrackedDeviceProperty", (void *)6);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_022_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_022_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_022_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_022_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_022_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_022_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_022_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_022_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_022_PollNextEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_PollNextEvent((void *)1, 2);
    check_ptr_parameter("IVRSystem_022_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_PollNextEvent", (void *)1);
    check_uint32_parameter("IVRSystem_022_PollNextEvent", 2);

    init_thunk(t, this_ptr_value, IVRSystem_022_PollNextEventWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSystem_022_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_022_PollNextEventWithPose", (void *)2);
    check_uint32_parameter("IVRSystem_022_PollNextEventWithPose", 3);
    check_ptr_parameter("IVRSystem_022_PollNextEventWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_022_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_022_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetHiddenAreaMesh, 3, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_022_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetHiddenAreaMesh(data_ptr_value, 1, 2);
    check_ptr_parameter("IVRSystem_022_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetHiddenAreaMesh", 1);
    check_uint32_parameter("IVRSystem_022_GetHiddenAreaMesh", 2);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetControllerState, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetControllerState(1, (void *)2, 3);
    check_ptr_parameter("IVRSystem_022_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_022_GetControllerState", (void *)2);
    check_uint32_parameter("IVRSystem_022_GetControllerState", 3);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetControllerStateWithPose, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_022_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_022_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_022_GetControllerStateWithPose", (void *)3);
    check_uint32_parameter("IVRSystem_022_GetControllerStateWithPose", 4);
    check_ptr_parameter("IVRSystem_022_GetControllerStateWithPose", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_022_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_022_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_022_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_022_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_022_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_022_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_022_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_022_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_022_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_022_IsInputAvailable, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_IsInputAvailable)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_IsInputAvailable();
    check_ptr_parameter("IVRSystem_022_IsInputAvailable", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_022_IsSteamVRDrawingControllers, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_IsSteamVRDrawingControllers)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_IsSteamVRDrawingControllers();
    check_ptr_parameter("IVRSystem_022_IsSteamVRDrawingControllers", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_022_ShouldApplicationPause, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_ShouldApplicationPause)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_ShouldApplicationPause();
    check_ptr_parameter("IVRSystem_022_ShouldApplicationPause", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_022_ShouldApplicationReduceRenderingWork, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_022_ShouldApplicationReduceRenderingWork)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_ShouldApplicationReduceRenderingWork();
    check_ptr_parameter("IVRSystem_022_ShouldApplicationReduceRenderingWork", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_022_PerformFirmwareUpdate, 1, FALSE, FALSE);
    EVRFirmwareError (__stdcall *capi_IVRSystem_022_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_022_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_022_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_022_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_022_AcknowledgeQuit_Exiting)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_AcknowledgeQuit_Exiting();
    check_ptr_parameter("IVRSystem_022_AcknowledgeQuit_Exiting", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetAppContainerFilePaths, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_022_GetAppContainerFilePaths)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetAppContainerFilePaths((void *)1, 2);
    check_ptr_parameter("IVRSystem_022_GetAppContainerFilePaths", this_ptr_value);
    check_ptr_parameter("IVRSystem_022_GetAppContainerFilePaths", (void *)1);
    check_uint32_parameter("IVRSystem_022_GetAppContainerFilePaths", 2);

    init_thunk(t, this_ptr_value, IVRSystem_022_GetRuntimeVersion, 0, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_022_GetRuntimeVersion)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_022_GetRuntimeVersion();
    check_ptr_parameter("IVRSystem_022_GetRuntimeVersion", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRApplications_007(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRApplications_007_AddApplicationManifest, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_AddApplicationManifest((void *)1, 1);
    check_ptr_parameter("IVRApplications_007_AddApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_AddApplicationManifest", (void *)1);
    check_bool_parameter("IVRApplications_007_AddApplicationManifest", 1);

    init_thunk(t, this_ptr_value, IVRApplications_007_RemoveApplicationManifest, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_RemoveApplicationManifest((void *)1);
    check_ptr_parameter("IVRApplications_007_RemoveApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_RemoveApplicationManifest", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_007_IsApplicationInstalled, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_007_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_IsApplicationInstalled((void *)1);
    check_ptr_parameter("IVRApplications_007_IsApplicationInstalled", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_IsApplicationInstalled", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_007_GetApplicationCount)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetApplicationCount();
    check_ptr_parameter("IVRApplications_007_GetApplicationCount", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationKeyByIndex, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetApplicationKeyByIndex(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_007_GetApplicationKeyByIndex", this_ptr_value);
    check_uint32_parameter("IVRApplications_007_GetApplicationKeyByIndex", 1);
    check_ptr_parameter("IVRApplications_007_GetApplicationKeyByIndex", (void *)2);
    check_uint32_parameter("IVRApplications_007_GetApplicationKeyByIndex", 3);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetApplicationKeyByProcessId(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_007_GetApplicationKeyByProcessId", this_ptr_value);
    check_uint32_parameter("IVRApplications_007_GetApplicationKeyByProcessId", 1);
    check_ptr_parameter("IVRApplications_007_GetApplicationKeyByProcessId", (void *)2);
    check_uint32_parameter("IVRApplications_007_GetApplicationKeyByProcessId", 3);

    init_thunk(t, this_ptr_value, IVRApplications_007_LaunchApplication, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_LaunchApplication)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_LaunchApplication((void *)1);
    check_ptr_parameter("IVRApplications_007_LaunchApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_LaunchApplication", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_007_LaunchTemplateApplication, 4, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_LaunchTemplateApplication)(const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_LaunchTemplateApplication((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRApplications_007_LaunchTemplateApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_LaunchTemplateApplication", (void *)1);
    check_ptr_parameter("IVRApplications_007_LaunchTemplateApplication", (void *)2);
    check_ptr_parameter("IVRApplications_007_LaunchTemplateApplication", (void *)3);
    check_uint32_parameter("IVRApplications_007_LaunchTemplateApplication", 4);

    init_thunk(t, this_ptr_value, IVRApplications_007_LaunchApplicationFromMimeType, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_LaunchApplicationFromMimeType)(const char * pchMimeType, const char * pchArgs) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_LaunchApplicationFromMimeType((void *)1, (void *)2);
    check_ptr_parameter("IVRApplications_007_LaunchApplicationFromMimeType", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_LaunchApplicationFromMimeType", (void *)1);
    check_ptr_parameter("IVRApplications_007_LaunchApplicationFromMimeType", (void *)2);

    init_thunk(t, this_ptr_value, IVRApplications_007_LaunchDashboardOverlay, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_LaunchDashboardOverlay((void *)1);
    check_ptr_parameter("IVRApplications_007_LaunchDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_LaunchDashboardOverlay", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_007_CancelApplicationLaunch, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_007_CancelApplicationLaunch)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_CancelApplicationLaunch((void *)1);
    check_ptr_parameter("IVRApplications_007_CancelApplicationLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_CancelApplicationLaunch", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_007_IdentifyApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_IdentifyApplication(1, (void *)2);
    check_ptr_parameter("IVRApplications_007_IdentifyApplication", this_ptr_value);
    check_uint32_parameter("IVRApplications_007_IdentifyApplication", 1);
    check_ptr_parameter("IVRApplications_007_IdentifyApplication", (void *)2);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationProcessId, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_007_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetApplicationProcessId((void *)1);
    check_ptr_parameter("IVRApplications_007_GetApplicationProcessId", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_GetApplicationProcessId", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_007_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetApplicationsErrorNameFromEnum(1);
    check_ptr_parameter("IVRApplications_007_GetApplicationsErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_007_GetApplicationsErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationPropertyString, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_007_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyString", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyString", (void *)1);
    check_uint32_parameter("IVRApplications_007_GetApplicationPropertyString", 2);
    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyString", (void *)3);
    check_uint32_parameter("IVRApplications_007_GetApplicationPropertyString", 4);
    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyString", (void *)5);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationPropertyBool, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_007_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetApplicationPropertyBool((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyBool", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyBool", (void *)1);
    check_uint32_parameter("IVRApplications_007_GetApplicationPropertyBool", 2);
    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyBool", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationPropertyUint64, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRApplications_007_GetApplicationPropertyUint64)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetApplicationPropertyUint64((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyUint64", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyUint64", (void *)1);
    check_uint32_parameter("IVRApplications_007_GetApplicationPropertyUint64", 2);
    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyUint64", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_007_SetApplicationAutoLaunch, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_SetApplicationAutoLaunch((void *)1, 1);
    check_ptr_parameter("IVRApplications_007_SetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_SetApplicationAutoLaunch", (void *)1);
    check_bool_parameter("IVRApplications_007_SetApplicationAutoLaunch", 1);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationAutoLaunch, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_007_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetApplicationAutoLaunch((void *)1);
    check_ptr_parameter("IVRApplications_007_GetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_GetApplicationAutoLaunch", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_007_SetDefaultApplicationForMimeType, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_SetDefaultApplicationForMimeType)(const char * pchAppKey, const char * pchMimeType) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_SetDefaultApplicationForMimeType((void *)1, (void *)2);
    check_ptr_parameter("IVRApplications_007_SetDefaultApplicationForMimeType", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_SetDefaultApplicationForMimeType", (void *)1);
    check_ptr_parameter("IVRApplications_007_SetDefaultApplicationForMimeType", (void *)2);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetDefaultApplicationForMimeType, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_007_GetDefaultApplicationForMimeType)(const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetDefaultApplicationForMimeType((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_007_GetDefaultApplicationForMimeType", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_GetDefaultApplicationForMimeType", (void *)1);
    check_ptr_parameter("IVRApplications_007_GetDefaultApplicationForMimeType", (void *)2);
    check_uint32_parameter("IVRApplications_007_GetDefaultApplicationForMimeType", 3);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationSupportedMimeTypes, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_007_GetApplicationSupportedMimeTypes)(const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetApplicationSupportedMimeTypes((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_007_GetApplicationSupportedMimeTypes", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_GetApplicationSupportedMimeTypes", (void *)1);
    check_ptr_parameter("IVRApplications_007_GetApplicationSupportedMimeTypes", (void *)2);
    check_uint32_parameter("IVRApplications_007_GetApplicationSupportedMimeTypes", 3);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationsThatSupportMimeType, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_007_GetApplicationsThatSupportMimeType)(const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetApplicationsThatSupportMimeType((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_007_GetApplicationsThatSupportMimeType", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_GetApplicationsThatSupportMimeType", (void *)1);
    check_ptr_parameter("IVRApplications_007_GetApplicationsThatSupportMimeType", (void *)2);
    check_uint32_parameter("IVRApplications_007_GetApplicationsThatSupportMimeType", 3);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationLaunchArguments, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_007_GetApplicationLaunchArguments)(uint32_t unHandle, char * pchArgs, uint32_t unArgs) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetApplicationLaunchArguments(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_007_GetApplicationLaunchArguments", this_ptr_value);
    check_uint32_parameter("IVRApplications_007_GetApplicationLaunchArguments", 1);
    check_ptr_parameter("IVRApplications_007_GetApplicationLaunchArguments", (void *)2);
    check_uint32_parameter("IVRApplications_007_GetApplicationLaunchArguments", 3);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetStartingApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetStartingApplication((void *)1, 2);
    check_ptr_parameter("IVRApplications_007_GetStartingApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_GetStartingApplication", (void *)1);
    check_uint32_parameter("IVRApplications_007_GetStartingApplication", 2);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetSceneApplicationState, 0, FALSE, FALSE);
    EVRSceneApplicationState (__stdcall *capi_IVRApplications_007_GetSceneApplicationState)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetSceneApplicationState();
    check_ptr_parameter("IVRApplications_007_GetSceneApplicationState", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_007_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_PerformApplicationPrelaunchCheck((void *)1);
    check_ptr_parameter("IVRApplications_007_PerformApplicationPrelaunchCheck", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_PerformApplicationPrelaunchCheck", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetSceneApplicationStateNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_007_GetSceneApplicationStateNameFromEnum)(EVRSceneApplicationState state) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetSceneApplicationStateNameFromEnum(1);
    check_ptr_parameter("IVRApplications_007_GetSceneApplicationStateNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_007_GetSceneApplicationStateNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_007_LaunchInternalProcess, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_007_LaunchInternalProcess)(const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory) = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_LaunchInternalProcess((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRApplications_007_LaunchInternalProcess", this_ptr_value);
    check_ptr_parameter("IVRApplications_007_LaunchInternalProcess", (void *)1);
    check_ptr_parameter("IVRApplications_007_LaunchInternalProcess", (void *)2);
    check_ptr_parameter("IVRApplications_007_LaunchInternalProcess", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_007_GetCurrentSceneProcessId, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_007_GetCurrentSceneProcessId)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_007_GetCurrentSceneProcessId();
    check_ptr_parameter("IVRApplications_007_GetCurrentSceneProcessId", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSettings_003(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSettings_003_GetSettingsErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSettings_003_GetSettingsErrorNameFromEnum)(EVRSettingsError eError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_003_GetSettingsErrorNameFromEnum(1);
    check_ptr_parameter("IVRSettings_003_GetSettingsErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSettings_003_GetSettingsErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSettings_003_SetBool, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_003_SetBool)(const char * pchSection, const char * pchSettingsKey, bool bValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_003_SetBool((void *)1, (void *)2, 1, (void *)4);
    check_ptr_parameter("IVRSettings_003_SetBool", this_ptr_value);
    check_ptr_parameter("IVRSettings_003_SetBool", (void *)1);
    check_ptr_parameter("IVRSettings_003_SetBool", (void *)2);
    check_bool_parameter("IVRSettings_003_SetBool", 1);
    check_ptr_parameter("IVRSettings_003_SetBool", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_003_SetInt32, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_003_SetInt32)(const char * pchSection, const char * pchSettingsKey, int32_t nValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_003_SetInt32((void *)1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSettings_003_SetInt32", this_ptr_value);
    check_ptr_parameter("IVRSettings_003_SetInt32", (void *)1);
    check_ptr_parameter("IVRSettings_003_SetInt32", (void *)2);
    check_uint32_parameter("IVRSettings_003_SetInt32", 3);
    check_ptr_parameter("IVRSettings_003_SetInt32", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_003_SetFloat, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSettings_003_SetFloat)(const char * pchSection, const char * pchSettingsKey, float flValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_003_SetFloat((void *)1, (void *)2, 3.0f, (void *)4);
    check_ptr_parameter("IVRSettings_003_SetFloat", this_ptr_value);
    check_ptr_parameter("IVRSettings_003_SetFloat", (void *)1);
    check_ptr_parameter("IVRSettings_003_SetFloat", (void *)2);
    check_float_parameter("IVRSettings_003_SetFloat", 3.0f);
    check_ptr_parameter("IVRSettings_003_SetFloat", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_003_SetString, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_003_SetString)(const char * pchSection, const char * pchSettingsKey, const char * pchValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_003_SetString((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSettings_003_SetString", this_ptr_value);
    check_ptr_parameter("IVRSettings_003_SetString", (void *)1);
    check_ptr_parameter("IVRSettings_003_SetString", (void *)2);
    check_ptr_parameter("IVRSettings_003_SetString", (void *)3);
    check_ptr_parameter("IVRSettings_003_SetString", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_003_GetBool, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSettings_003_GetBool)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_003_GetBool((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSettings_003_GetBool", this_ptr_value);
    check_ptr_parameter("IVRSettings_003_GetBool", (void *)1);
    check_ptr_parameter("IVRSettings_003_GetBool", (void *)2);
    check_ptr_parameter("IVRSettings_003_GetBool", (void *)3);

    init_thunk(t, this_ptr_value, IVRSettings_003_GetInt32, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSettings_003_GetInt32)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_003_GetInt32((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSettings_003_GetInt32", this_ptr_value);
    check_ptr_parameter("IVRSettings_003_GetInt32", (void *)1);
    check_ptr_parameter("IVRSettings_003_GetInt32", (void *)2);
    check_ptr_parameter("IVRSettings_003_GetInt32", (void *)3);

    init_thunk(t, this_ptr_value, IVRSettings_003_GetFloat, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSettings_003_GetFloat)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_003_GetFloat((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSettings_003_GetFloat", this_ptr_value);
    check_ptr_parameter("IVRSettings_003_GetFloat", (void *)1);
    check_ptr_parameter("IVRSettings_003_GetFloat", (void *)2);
    check_ptr_parameter("IVRSettings_003_GetFloat", (void *)3);

    init_thunk(t, this_ptr_value, IVRSettings_003_GetString, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_003_GetString)(const char * pchSection, const char * pchSettingsKey, char * pchValue, uint32_t unValueLen, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_003_GetString((void *)1, (void *)2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSettings_003_GetString", this_ptr_value);
    check_ptr_parameter("IVRSettings_003_GetString", (void *)1);
    check_ptr_parameter("IVRSettings_003_GetString", (void *)2);
    check_ptr_parameter("IVRSettings_003_GetString", (void *)3);
    check_uint32_parameter("IVRSettings_003_GetString", 4);
    check_ptr_parameter("IVRSettings_003_GetString", (void *)5);

    init_thunk(t, this_ptr_value, IVRSettings_003_RemoveSection, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_003_RemoveSection)(const char * pchSection, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_003_RemoveSection((void *)1, (void *)2);
    check_ptr_parameter("IVRSettings_003_RemoveSection", this_ptr_value);
    check_ptr_parameter("IVRSettings_003_RemoveSection", (void *)1);
    check_ptr_parameter("IVRSettings_003_RemoveSection", (void *)2);

    init_thunk(t, this_ptr_value, IVRSettings_003_RemoveKeyInSection, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_003_RemoveKeyInSection)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_003_RemoveKeyInSection((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSettings_003_RemoveKeyInSection", this_ptr_value);
    check_ptr_parameter("IVRSettings_003_RemoveKeyInSection", (void *)1);
    check_ptr_parameter("IVRSettings_003_RemoveKeyInSection", (void *)2);
    check_ptr_parameter("IVRSettings_003_RemoveKeyInSection", (void *)3);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRChaperone_004(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRChaperone_004_GetCalibrationState, 0, FALSE, FALSE);
    ChaperoneCalibrationState (__stdcall *capi_IVRChaperone_004_GetCalibrationState)() = (void *)t;

    clear_parameters();
    capi_IVRChaperone_004_GetCalibrationState();
    check_ptr_parameter("IVRChaperone_004_GetCalibrationState", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperone_004_GetPlayAreaSize, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperone_004_GetPlayAreaSize)(float * pSizeX, float * pSizeZ) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_004_GetPlayAreaSize((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperone_004_GetPlayAreaSize", this_ptr_value);
    check_ptr_parameter("IVRChaperone_004_GetPlayAreaSize", (void *)1);
    check_ptr_parameter("IVRChaperone_004_GetPlayAreaSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperone_004_GetPlayAreaRect, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperone_004_GetPlayAreaRect)(HmdQuad_t * rect) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_004_GetPlayAreaRect((void *)1);
    check_ptr_parameter("IVRChaperone_004_GetPlayAreaRect", this_ptr_value);
    check_ptr_parameter("IVRChaperone_004_GetPlayAreaRect", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperone_004_ReloadInfo, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperone_004_ReloadInfo)() = (void *)t;

    clear_parameters();
    capi_IVRChaperone_004_ReloadInfo();
    check_ptr_parameter("IVRChaperone_004_ReloadInfo", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperone_004_SetSceneColor, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperone_004_SetSceneColor)(HmdColor_t color) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_004_SetSceneColor(DEFAULT_COLOR);
    check_ptr_parameter("IVRChaperone_004_SetSceneColor", this_ptr_value);
    check_HmdColor_parameter("IVRChaperone_004_SetSceneColor", DEFAULT_COLOR);

    init_thunk(t, this_ptr_value, IVRChaperone_004_GetBoundsColor, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRChaperone_004_GetBoundsColor)(HmdColor_t * pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t * pOutputCameraColor) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_004_GetBoundsColor((void *)1, 2, 3.0f, (void *)4);
    check_ptr_parameter("IVRChaperone_004_GetBoundsColor", this_ptr_value);
    check_ptr_parameter("IVRChaperone_004_GetBoundsColor", (void *)1);
    check_uint32_parameter("IVRChaperone_004_GetBoundsColor", 2);
    check_float_parameter("IVRChaperone_004_GetBoundsColor", 3.0f);
    check_ptr_parameter("IVRChaperone_004_GetBoundsColor", (void *)4);

    init_thunk(t, this_ptr_value, IVRChaperone_004_AreBoundsVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperone_004_AreBoundsVisible)() = (void *)t;

    clear_parameters();
    capi_IVRChaperone_004_AreBoundsVisible();
    check_ptr_parameter("IVRChaperone_004_AreBoundsVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperone_004_ForceBoundsVisible, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperone_004_ForceBoundsVisible)(bool bForce) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_004_ForceBoundsVisible(1);
    check_ptr_parameter("IVRChaperone_004_ForceBoundsVisible", this_ptr_value);
    check_bool_parameter("IVRChaperone_004_ForceBoundsVisible", 1);

    init_thunk(t, this_ptr_value, IVRChaperone_004_ResetZeroPose, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperone_004_ResetZeroPose)(ETrackingUniverseOrigin eTrackingUniverseOrigin) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_004_ResetZeroPose(1);
    check_ptr_parameter("IVRChaperone_004_ResetZeroPose", this_ptr_value);
    check_uint32_parameter("IVRChaperone_004_ResetZeroPose", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRChaperoneSetup_006(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_CommitWorkingCopy, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_006_CommitWorkingCopy)(EChaperoneConfigFile configFile) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_CommitWorkingCopy(1);
    check_ptr_parameter("IVRChaperoneSetup_006_CommitWorkingCopy", this_ptr_value);
    check_uint32_parameter("IVRChaperoneSetup_006_CommitWorkingCopy", 1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_RevertWorkingCopy, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_006_RevertWorkingCopy)() = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_RevertWorkingCopy();
    check_ptr_parameter("IVRChaperoneSetup_006_RevertWorkingCopy", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_GetWorkingPlayAreaSize, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_006_GetWorkingPlayAreaSize)(float * pSizeX, float * pSizeZ) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_GetWorkingPlayAreaSize((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_006_GetWorkingPlayAreaSize", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_GetWorkingPlayAreaSize", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_006_GetWorkingPlayAreaSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_GetWorkingPlayAreaRect, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_006_GetWorkingPlayAreaRect)(HmdQuad_t * rect) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_GetWorkingPlayAreaRect((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_006_GetWorkingPlayAreaRect", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_GetWorkingPlayAreaRect", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_GetWorkingCollisionBoundsInfo, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_006_GetWorkingCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_GetWorkingCollisionBoundsInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_006_GetWorkingCollisionBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_GetWorkingCollisionBoundsInfo", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_006_GetWorkingCollisionBoundsInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_GetLiveCollisionBoundsInfo, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_006_GetLiveCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_GetLiveCollisionBoundsInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_006_GetLiveCollisionBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_GetLiveCollisionBoundsInfo", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_006_GetLiveCollisionBoundsInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_GetWorkingSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_006_GetWorkingSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_GetWorkingSeatedZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_006_GetWorkingSeatedZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_GetWorkingSeatedZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_GetWorkingStandingZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_006_GetWorkingStandingZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatStandingZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_GetWorkingStandingZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_006_GetWorkingStandingZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_GetWorkingStandingZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_SetWorkingPlayAreaSize, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_006_SetWorkingPlayAreaSize)(float sizeX, float sizeZ) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_SetWorkingPlayAreaSize(1.0f, 2.0f);
    check_ptr_parameter("IVRChaperoneSetup_006_SetWorkingPlayAreaSize", this_ptr_value);
    check_float_parameter("IVRChaperoneSetup_006_SetWorkingPlayAreaSize", 1.0f);
    check_float_parameter("IVRChaperoneSetup_006_SetWorkingPlayAreaSize", 2.0f);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_SetWorkingCollisionBoundsInfo, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_006_SetWorkingCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_SetWorkingCollisionBoundsInfo((void *)1, 2);
    check_ptr_parameter("IVRChaperoneSetup_006_SetWorkingCollisionBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_SetWorkingCollisionBoundsInfo", (void *)1);
    check_uint32_parameter("IVRChaperoneSetup_006_SetWorkingCollisionBoundsInfo", 2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_SetWorkingPerimeter, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_006_SetWorkingPerimeter)(HmdVector2_t * pPointBuffer, uint32_t unPointCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_SetWorkingPerimeter((void *)1, 2);
    check_ptr_parameter("IVRChaperoneSetup_006_SetWorkingPerimeter", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_SetWorkingPerimeter", (void *)1);
    check_uint32_parameter("IVRChaperoneSetup_006_SetWorkingPerimeter", 2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_SetWorkingSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_006_SetWorkingSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pMatSeatedZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_SetWorkingSeatedZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_006_SetWorkingSeatedZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_SetWorkingSeatedZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_SetWorkingStandingZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_006_SetWorkingStandingZeroPoseToRawTrackingPose)(HmdMatrix34_t * pMatStandingZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_SetWorkingStandingZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_006_SetWorkingStandingZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_SetWorkingStandingZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_ReloadFromDisk, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_006_ReloadFromDisk)(EChaperoneConfigFile configFile) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_ReloadFromDisk(1);
    check_ptr_parameter("IVRChaperoneSetup_006_ReloadFromDisk", this_ptr_value);
    check_uint32_parameter("IVRChaperoneSetup_006_ReloadFromDisk", 1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_GetLiveSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_006_GetLiveSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_GetLiveSeatedZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_006_GetLiveSeatedZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_GetLiveSeatedZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_ExportLiveToBuffer, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_006_ExportLiveToBuffer)(char * pBuffer, uint32_t * pnBufferLength) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_ExportLiveToBuffer((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_006_ExportLiveToBuffer", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_ExportLiveToBuffer", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_006_ExportLiveToBuffer", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_ImportFromBufferToWorking, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_006_ImportFromBufferToWorking)(const char * pBuffer, uint32_t nImportFlags) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_ImportFromBufferToWorking((void *)1, 2);
    check_ptr_parameter("IVRChaperoneSetup_006_ImportFromBufferToWorking", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_006_ImportFromBufferToWorking", (void *)1);
    check_uint32_parameter("IVRChaperoneSetup_006_ImportFromBufferToWorking", 2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_ShowWorkingSetPreview, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_006_ShowWorkingSetPreview)() = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_ShowWorkingSetPreview();
    check_ptr_parameter("IVRChaperoneSetup_006_ShowWorkingSetPreview", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_HideWorkingSetPreview, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_006_HideWorkingSetPreview)() = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_HideWorkingSetPreview();
    check_ptr_parameter("IVRChaperoneSetup_006_HideWorkingSetPreview", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_006_RoomSetupStarting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_006_RoomSetupStarting)() = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_006_RoomSetupStarting();
    check_ptr_parameter("IVRChaperoneSetup_006_RoomSetupStarting", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_027(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_027_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_027_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_027_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_027_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_027_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_027_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_027_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_027_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_027_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_027_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_027_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_027_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_027_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_027_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_027_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_027_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_027_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_027_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_027_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_027_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_027_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_027_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_027_Submit", 1);
    check_ptr_parameter("IVRCompositor_027_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_027_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_027_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_027_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_027_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_027_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_027_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_027_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_027_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetFrameTimings, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_027_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetFrameTimings((void *)1, 2);
    check_ptr_parameter("IVRCompositor_027_GetFrameTimings", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_GetFrameTimings", (void *)1);
    check_uint32_parameter("IVRCompositor_027_GetFrameTimings", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_027_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_027_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetCumulativeStats, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetCumulativeStats((void *)1, 2);
    check_ptr_parameter("IVRCompositor_027_GetCumulativeStats", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_GetCumulativeStats", (void *)1);
    check_uint32_parameter("IVRCompositor_027_GetCumulativeStats", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_027_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_027_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_027_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_027_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_027_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_027_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_027_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_027_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_027_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetCurrentFadeColor, 2, FALSE, FALSE);
    HmdColor_t *(__stdcall *capi_IVRCompositor_027_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetCurrentFadeColor(data_ptr_value, 1);
    check_ptr_parameter("IVRCompositor_027_GetCurrentFadeColor", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_GetCurrentFadeColor", data_ptr_value);
    check_bool_parameter("IVRCompositor_027_GetCurrentFadeColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_027_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_FadeGrid)(float fSeconds, bool bFadeGridIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_027_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_027_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_027_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetCurrentGridAlpha, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_027_GetCurrentGridAlpha)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetCurrentGridAlpha();
    check_ptr_parameter("IVRCompositor_027_GetCurrentGridAlpha", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_027_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_027_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_027_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_027_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_027_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_027_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_027_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_CompositorQuit();
    check_ptr_parameter("IVRCompositor_027_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_027_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_IsFullscreen();
    check_ptr_parameter("IVRCompositor_027_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_027_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_027_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_027_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_027_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_027_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_CanRenderScene();
    check_ptr_parameter("IVRCompositor_027_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_027_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_027_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_027_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_027_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_027_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_027_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_027_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_027_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_027_ForceInterleavedReprojectionOn", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_027_ForceReconnectProcess, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_ForceReconnectProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_ForceReconnectProcess();
    check_ptr_parameter("IVRCompositor_027_ForceReconnectProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_SuspendRendering, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_SuspendRendering)(bool bSuspend) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_SuspendRendering(1);
    check_ptr_parameter("IVRCompositor_027_SuspendRendering", this_ptr_value);
    check_bool_parameter("IVRCompositor_027_SuspendRendering", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetMirrorTextureD3D11, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_027_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_027_GetMirrorTextureD3D11", this_ptr_value);
    check_uint32_parameter("IVRCompositor_027_GetMirrorTextureD3D11", 1);
    check_ptr_parameter("IVRCompositor_027_GetMirrorTextureD3D11", (void *)2);
    check_ptr_parameter("IVRCompositor_027_GetMirrorTextureD3D11", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_027_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_ReleaseMirrorTextureD3D11((void *)1);
    check_ptr_parameter("IVRCompositor_027_ReleaseMirrorTextureD3D11", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_ReleaseMirrorTextureD3D11", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetMirrorTextureGL, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_027_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetMirrorTextureGL(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_027_GetMirrorTextureGL", this_ptr_value);
    check_uint32_parameter("IVRCompositor_027_GetMirrorTextureGL", 1);
    check_ptr_parameter("IVRCompositor_027_GetMirrorTextureGL", (void *)2);
    check_ptr_parameter("IVRCompositor_027_GetMirrorTextureGL", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_027_ReleaseSharedGLTexture, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_027_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_ReleaseSharedGLTexture(1, (void *)2);
    check_ptr_parameter("IVRCompositor_027_ReleaseSharedGLTexture", this_ptr_value);
    check_uint32_parameter("IVRCompositor_027_ReleaseSharedGLTexture", 1);
    check_ptr_parameter("IVRCompositor_027_ReleaseSharedGLTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_027_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_LockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_027_LockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_LockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_027_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_UnlockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_027_UnlockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_UnlockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_027_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetVulkanInstanceExtensionsRequired((void *)1, 2);
    check_ptr_parameter("IVRCompositor_027_GetVulkanInstanceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_GetVulkanInstanceExtensionsRequired", (void *)1);
    check_uint32_parameter("IVRCompositor_027_GetVulkanInstanceExtensionsRequired", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_027_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRCompositor_027_GetVulkanDeviceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_GetVulkanDeviceExtensionsRequired", (void *)1);
    check_ptr_parameter("IVRCompositor_027_GetVulkanDeviceExtensionsRequired", (void *)2);
    check_uint32_parameter("IVRCompositor_027_GetVulkanDeviceExtensionsRequired", 3);

    init_thunk(t, this_ptr_value, IVRCompositor_027_SetExplicitTimingMode, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_SetExplicitTimingMode)(EVRCompositorTimingMode eTimingMode) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_SetExplicitTimingMode(1);
    check_ptr_parameter("IVRCompositor_027_SetExplicitTimingMode", this_ptr_value);
    check_uint32_parameter("IVRCompositor_027_SetExplicitTimingMode", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_027_SubmitExplicitTimingData, 0, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_027_SubmitExplicitTimingData)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_SubmitExplicitTimingData();
    check_ptr_parameter("IVRCompositor_027_SubmitExplicitTimingData", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_IsMotionSmoothingEnabled, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_027_IsMotionSmoothingEnabled)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_IsMotionSmoothingEnabled();
    check_ptr_parameter("IVRCompositor_027_IsMotionSmoothingEnabled", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_IsMotionSmoothingSupported, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_027_IsMotionSmoothingSupported)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_IsMotionSmoothingSupported();
    check_ptr_parameter("IVRCompositor_027_IsMotionSmoothingSupported", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_IsCurrentSceneFocusAppLoading, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_027_IsCurrentSceneFocusAppLoading)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_IsCurrentSceneFocusAppLoading();
    check_ptr_parameter("IVRCompositor_027_IsCurrentSceneFocusAppLoading", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_SetStageOverride_Async, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_027_SetStageOverride_Async)(const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_SetStageOverride_Async((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_027_SetStageOverride_Async", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_SetStageOverride_Async", (void *)1);
    check_ptr_parameter("IVRCompositor_027_SetStageOverride_Async", (void *)2);
    check_ptr_parameter("IVRCompositor_027_SetStageOverride_Async", (void *)3);
    check_uint32_parameter("IVRCompositor_027_SetStageOverride_Async", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_027_ClearStageOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_027_ClearStageOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_ClearStageOverride();
    check_ptr_parameter("IVRCompositor_027_ClearStageOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetCompositorBenchmarkResults, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_027_GetCompositorBenchmarkResults)(Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetCompositorBenchmarkResults((void *)1, 2);
    check_ptr_parameter("IVRCompositor_027_GetCompositorBenchmarkResults", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_GetCompositorBenchmarkResults", (void *)1);
    check_uint32_parameter("IVRCompositor_027_GetCompositorBenchmarkResults", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetLastPosePredictionIDs, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_027_GetLastPosePredictionIDs)(uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetLastPosePredictionIDs((void *)1, (void *)2);
    check_ptr_parameter("IVRCompositor_027_GetLastPosePredictionIDs", this_ptr_value);
    check_ptr_parameter("IVRCompositor_027_GetLastPosePredictionIDs", (void *)1);
    check_ptr_parameter("IVRCompositor_027_GetLastPosePredictionIDs", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_027_GetPosesForFrame, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_027_GetPosesForFrame)(uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_027_GetPosesForFrame(1, (void *)2, 3);
    check_ptr_parameter("IVRCompositor_027_GetPosesForFrame", this_ptr_value);
    check_uint32_parameter("IVRCompositor_027_GetPosesForFrame", 1);
    check_ptr_parameter("IVRCompositor_027_GetPosesForFrame", (void *)2);
    check_uint32_parameter("IVRCompositor_027_GetPosesForFrame", 3);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRHeadsetView_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRHeadsetView_001_SetHeadsetViewSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRHeadsetView_001_SetHeadsetViewSize)(uint32_t nWidth, uint32_t nHeight) = (void *)t;

    clear_parameters();
    capi_IVRHeadsetView_001_SetHeadsetViewSize(1, 2);
    check_ptr_parameter("IVRHeadsetView_001_SetHeadsetViewSize", this_ptr_value);
    check_uint32_parameter("IVRHeadsetView_001_SetHeadsetViewSize", 1);
    check_uint32_parameter("IVRHeadsetView_001_SetHeadsetViewSize", 2);

    init_thunk(t, this_ptr_value, IVRHeadsetView_001_GetHeadsetViewSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRHeadsetView_001_GetHeadsetViewSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRHeadsetView_001_GetHeadsetViewSize((void *)1, (void *)2);
    check_ptr_parameter("IVRHeadsetView_001_GetHeadsetViewSize", this_ptr_value);
    check_ptr_parameter("IVRHeadsetView_001_GetHeadsetViewSize", (void *)1);
    check_ptr_parameter("IVRHeadsetView_001_GetHeadsetViewSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRHeadsetView_001_SetHeadsetViewMode, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRHeadsetView_001_SetHeadsetViewMode)(HeadsetViewMode_t eHeadsetViewMode) = (void *)t;

    clear_parameters();
    capi_IVRHeadsetView_001_SetHeadsetViewMode(1);
    check_ptr_parameter("IVRHeadsetView_001_SetHeadsetViewMode", this_ptr_value);
    check_uint32_parameter("IVRHeadsetView_001_SetHeadsetViewMode", 1);

    init_thunk(t, this_ptr_value, IVRHeadsetView_001_GetHeadsetViewMode, 0, FALSE, FALSE);
    HeadsetViewMode_t (__stdcall *capi_IVRHeadsetView_001_GetHeadsetViewMode)() = (void *)t;

    clear_parameters();
    capi_IVRHeadsetView_001_GetHeadsetViewMode();
    check_ptr_parameter("IVRHeadsetView_001_GetHeadsetViewMode", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRHeadsetView_001_SetHeadsetViewCropped, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRHeadsetView_001_SetHeadsetViewCropped)(bool bCropped) = (void *)t;

    clear_parameters();
    capi_IVRHeadsetView_001_SetHeadsetViewCropped(1);
    check_ptr_parameter("IVRHeadsetView_001_SetHeadsetViewCropped", this_ptr_value);
    check_bool_parameter("IVRHeadsetView_001_SetHeadsetViewCropped", 1);

    init_thunk(t, this_ptr_value, IVRHeadsetView_001_GetHeadsetViewCropped, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRHeadsetView_001_GetHeadsetViewCropped)() = (void *)t;

    clear_parameters();
    capi_IVRHeadsetView_001_GetHeadsetViewCropped();
    check_ptr_parameter("IVRHeadsetView_001_GetHeadsetViewCropped", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRHeadsetView_001_GetHeadsetViewAspectRatio, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRHeadsetView_001_GetHeadsetViewAspectRatio)() = (void *)t;

    clear_parameters();
    capi_IVRHeadsetView_001_GetHeadsetViewAspectRatio();
    check_ptr_parameter("IVRHeadsetView_001_GetHeadsetViewAspectRatio", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRHeadsetView_001_SetHeadsetViewBlendRange, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRHeadsetView_001_SetHeadsetViewBlendRange)(float flStartPct, float flEndPct) = (void *)t;

    clear_parameters();
    capi_IVRHeadsetView_001_SetHeadsetViewBlendRange(1.0f, 2.0f);
    check_ptr_parameter("IVRHeadsetView_001_SetHeadsetViewBlendRange", this_ptr_value);
    check_float_parameter("IVRHeadsetView_001_SetHeadsetViewBlendRange", 1.0f);
    check_float_parameter("IVRHeadsetView_001_SetHeadsetViewBlendRange", 2.0f);

    init_thunk(t, this_ptr_value, IVRHeadsetView_001_GetHeadsetViewBlendRange, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRHeadsetView_001_GetHeadsetViewBlendRange)(float * pStartPct, float * pEndPct) = (void *)t;

    clear_parameters();
    capi_IVRHeadsetView_001_GetHeadsetViewBlendRange((void *)1, (void *)2);
    check_ptr_parameter("IVRHeadsetView_001_GetHeadsetViewBlendRange", this_ptr_value);
    check_ptr_parameter("IVRHeadsetView_001_GetHeadsetViewBlendRange", (void *)1);
    check_ptr_parameter("IVRHeadsetView_001_GetHeadsetViewBlendRange", (void *)2);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRNotifications_002(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRNotifications_002_CreateNotification, 7, FALSE, FALSE);
    EVRNotificationError (__stdcall *capi_IVRNotifications_002_CreateNotification)(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char * pchText, EVRNotificationStyle style, NotificationBitmap_t * pImage, VRNotificationId * pNotificationId) = (void *)t;

    clear_parameters();
    capi_IVRNotifications_002_CreateNotification(1, 2, 3, (void *)4, 5, (void *)6, (void *)7);
    check_ptr_parameter("IVRNotifications_002_CreateNotification", this_ptr_value);
    check_uint64_parameter("IVRNotifications_002_CreateNotification", 1);
    check_uint64_parameter("IVRNotifications_002_CreateNotification", 2);
    check_uint32_parameter("IVRNotifications_002_CreateNotification", 3);
    check_ptr_parameter("IVRNotifications_002_CreateNotification", (void *)4);
    check_uint32_parameter("IVRNotifications_002_CreateNotification", 5);
    check_ptr_parameter("IVRNotifications_002_CreateNotification", (void *)6);
    check_ptr_parameter("IVRNotifications_002_CreateNotification", (void *)7);

    init_thunk(t, this_ptr_value, IVRNotifications_002_RemoveNotification, 1, FALSE, FALSE);
    EVRNotificationError (__stdcall *capi_IVRNotifications_002_RemoveNotification)(VRNotificationId notificationId) = (void *)t;

    clear_parameters();
    capi_IVRNotifications_002_RemoveNotification(1);
    check_ptr_parameter("IVRNotifications_002_RemoveNotification", this_ptr_value);
    check_uint32_parameter("IVRNotifications_002_RemoveNotification", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_025(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_025_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_025_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_025_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_025_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_025_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_025_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_025_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_025_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_025_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_025_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_025_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_025_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_025_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_025_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_025_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_025_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_025_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_025_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayName, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayName(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_SetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayName", 1);
    check_ptr_parameter("IVROverlay_025_SetOverlayName", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_025_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_025_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_025_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_025_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_025_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_025_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_025_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_025_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_025_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_025_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_025_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_025_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_025_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_025_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_025_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_025_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_025_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayFlags, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayFlags(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayFlags", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayFlags", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayFlags", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_025_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_025_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_025_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_025_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_025_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_025_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_025_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_025_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTexelAspect, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayTexelAspect(1, 2.0f);
    check_ptr_parameter("IVROverlay_025_SetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayTexelAspect", 1);
    check_float_parameter("IVROverlay_025_SetOverlayTexelAspect", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTexelAspect, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayTexelAspect(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayTexelAspect", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayTexelAspect", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlaySortOrder(1, 2);
    check_ptr_parameter("IVROverlay_025_SetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlaySortOrder", 1);
    check_uint32_parameter("IVROverlay_025_SetOverlaySortOrder", 2);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlaySortOrder(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlaySortOrder", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlaySortOrder", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_025_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_025_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayCurvature, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float fCurvature) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayCurvature(1, 2.0f);
    check_ptr_parameter("IVROverlay_025_SetOverlayCurvature", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayCurvature", 1);
    check_float_parameter("IVROverlay_025_SetOverlayCurvature", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayCurvature, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float * pfCurvature) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayCurvature(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayCurvature", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayCurvature", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayCurvature", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_025_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_025_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_025_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_025_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayTransformOverlayRelative", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformOverlayRelative", (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayTransformOverlayRelative", 1);
    check_uint64_parameter("IVROverlay_025_SetOverlayTransformOverlayRelative", 2);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTransformCursor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTransformCursor)(VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayTransformCursor(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformCursor", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayTransformCursor", 1);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformCursor", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTransformCursor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTransformCursor)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayTransformCursor(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformCursor", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayTransformCursor", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayTransformCursor", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTransformProjection, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTransformProjection)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayTransformProjection(1, 2, (void *)3, (void *)4, 5);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformProjection", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayTransformProjection", 1);
    check_uint32_parameter("IVROverlay_025_SetOverlayTransformProjection", 2);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformProjection", (void *)3);
    check_ptr_parameter("IVROverlay_025_SetOverlayTransformProjection", (void *)4);
    check_uint32_parameter("IVROverlay_025_SetOverlayTransformProjection", 5);

    init_thunk(t, this_ptr_value, IVROverlay_025_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_025_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_025_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_HideOverlay(1);
    check_ptr_parameter("IVROverlay_025_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_025_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_025_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_025_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_025_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_025_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_025_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_025_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_025_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_025_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_025_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_025_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_025_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_025_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_025_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_025_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_025_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_025_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_025_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_025_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_025_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_025_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_025_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayIntersectionMask, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
    check_ptr_parameter("IVROverlay_025_SetOverlayIntersectionMask", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayIntersectionMask", 1);
    check_ptr_parameter("IVROverlay_025_SetOverlayIntersectionMask", (void *)2);
    check_uint32_parameter("IVROverlay_025_SetOverlayIntersectionMask", 3);
    check_uint32_parameter("IVROverlay_025_SetOverlayIntersectionMask", 4);

    init_thunk(t, this_ptr_value, IVROverlay_025_TriggerLaserMouseHapticVibration, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_TriggerLaserMouseHapticVibration)(VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_TriggerLaserMouseHapticVibration(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_025_TriggerLaserMouseHapticVibration", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_TriggerLaserMouseHapticVibration", 1);
    check_float_parameter("IVROverlay_025_TriggerLaserMouseHapticVibration", 2.0f);
    check_float_parameter("IVROverlay_025_TriggerLaserMouseHapticVibration", 3.0f);
    check_float_parameter("IVROverlay_025_TriggerLaserMouseHapticVibration", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayCursor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayCursor)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayCursor(1, 2);
    check_ptr_parameter("IVROverlay_025_SetOverlayCursor", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayCursor", 1);
    check_uint64_parameter("IVROverlay_025_SetOverlayCursor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayCursorPositionOverride, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayCursorPositionOverride(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_SetOverlayCursorPositionOverride", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayCursorPositionOverride", 1);
    check_ptr_parameter("IVROverlay_025_SetOverlayCursorPositionOverride", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_ClearOverlayCursorPositionOverride, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_ClearOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_ClearOverlayCursorPositionOverride(1);
    check_ptr_parameter("IVROverlay_025_ClearOverlayCursorPositionOverride", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_ClearOverlayCursorPositionOverride", 1);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_025_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_025_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_025_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_025_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_025_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_025_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_025_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_025_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTexture, 9, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)8);
    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)9);

    init_thunk(t, this_ptr_value, IVROverlay_025_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_025_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTextureSize, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetOverlayTextureSize(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_025_GetOverlayTextureSize", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetOverlayTextureSize", 1);
    check_ptr_parameter("IVROverlay_025_GetOverlayTextureSize", (void *)2);
    check_ptr_parameter("IVROverlay_025_GetOverlayTextureSize", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_025_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_025_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_025_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_025_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_025_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_025_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_025_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_025_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_025_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_025_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_025_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_025_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_025_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_025_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_025_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_025_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_025_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_025_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_025_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_025_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_025_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_ShowKeyboard(1, 2, 3, (void *)4, 5, (void *)6, 7);
    check_ptr_parameter("IVROverlay_025_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_025_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_025_ShowKeyboard", 2);
    check_uint32_parameter("IVROverlay_025_ShowKeyboard", 3);
    check_ptr_parameter("IVROverlay_025_ShowKeyboard", (void *)4);
    check_uint32_parameter("IVROverlay_025_ShowKeyboard", 5);
    check_ptr_parameter("IVROverlay_025_ShowKeyboard", (void *)6);
    check_uint64_parameter("IVROverlay_025_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_025_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_025_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_ShowKeyboardForOverlay(1, 2, 3, 4, (void *)5, 6, (void *)7, 8);
    check_ptr_parameter("IVROverlay_025_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_025_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_025_ShowKeyboardForOverlay", 3);
    check_uint32_parameter("IVROverlay_025_ShowKeyboardForOverlay", 4);
    check_ptr_parameter("IVROverlay_025_ShowKeyboardForOverlay", (void *)5);
    check_uint32_parameter("IVROverlay_025_ShowKeyboardForOverlay", 6);
    check_ptr_parameter("IVROverlay_025_ShowKeyboardForOverlay", (void *)7);
    check_uint64_parameter("IVROverlay_025_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_025_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_025_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_025_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_025_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_025_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_025_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_025_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_HideKeyboard();
    check_ptr_parameter("IVROverlay_025_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_025_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_025_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_025_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_025_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_025_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_025_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_025_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_025_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_025_SetKeyboardPositionForOverlay", DEFAULT_RECT);

    init_thunk(t, this_ptr_value, IVROverlay_025_ShowMessageOverlay, 6, FALSE, FALSE);
    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_025_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", (void *)4);
    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", (void *)5);
    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", (void *)6);

    init_thunk(t, this_ptr_value, IVROverlay_025_CloseMessageOverlay, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_025_CloseMessageOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_025_CloseMessageOverlay();
    check_ptr_parameter("IVROverlay_025_CloseMessageOverlay", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlayView_003(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlayView_003_AcquireOverlayView, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlayView_003_AcquireOverlayView)(VROverlayHandle_t ulOverlayHandle, VRNativeDevice_t * pNativeDevice, VROverlayView_t * pOverlayView, uint32_t unOverlayViewSize) = (void *)t;

    clear_parameters();
    capi_IVROverlayView_003_AcquireOverlayView(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlayView_003_AcquireOverlayView", this_ptr_value);
    check_uint64_parameter("IVROverlayView_003_AcquireOverlayView", 1);
    check_ptr_parameter("IVROverlayView_003_AcquireOverlayView", (void *)2);
    check_ptr_parameter("IVROverlayView_003_AcquireOverlayView", (void *)3);
    check_uint32_parameter("IVROverlayView_003_AcquireOverlayView", 4);

    init_thunk(t, this_ptr_value, IVROverlayView_003_ReleaseOverlayView, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlayView_003_ReleaseOverlayView)(VROverlayView_t * pOverlayView) = (void *)t;

    clear_parameters();
    capi_IVROverlayView_003_ReleaseOverlayView((void *)1);
    check_ptr_parameter("IVROverlayView_003_ReleaseOverlayView", this_ptr_value);
    check_ptr_parameter("IVROverlayView_003_ReleaseOverlayView", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlayView_003_PostOverlayEvent, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlayView_003_PostOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pvrEvent) = (void *)t;

    clear_parameters();
    capi_IVROverlayView_003_PostOverlayEvent(1, (void *)2);
    check_ptr_parameter("IVROverlayView_003_PostOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlayView_003_PostOverlayEvent", 1);
    check_ptr_parameter("IVROverlayView_003_PostOverlayEvent", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlayView_003_IsViewingPermitted, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlayView_003_IsViewingPermitted)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlayView_003_IsViewingPermitted(1);
    check_ptr_parameter("IVROverlayView_003_IsViewingPermitted", this_ptr_value);
    check_uint64_parameter("IVROverlayView_003_IsViewingPermitted", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRRenderModels_006(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_LoadRenderModel_Async, 2, FALSE, FALSE);
    EVRRenderModelError (__stdcall *capi_IVRRenderModels_006_LoadRenderModel_Async)(const char * pchRenderModelName, RenderModel_t ** ppRenderModel) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_LoadRenderModel_Async((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_006_LoadRenderModel_Async", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_LoadRenderModel_Async", (void *)1);
    check_ptr_parameter("IVRRenderModels_006_LoadRenderModel_Async", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_FreeRenderModel, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRRenderModels_006_FreeRenderModel)(RenderModel_t * pRenderModel) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_FreeRenderModel((void *)1);
    check_ptr_parameter("IVRRenderModels_006_FreeRenderModel", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_FreeRenderModel", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_LoadTexture_Async, 2, FALSE, FALSE);
    EVRRenderModelError (__stdcall *capi_IVRRenderModels_006_LoadTexture_Async)(TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_LoadTexture_Async(1, (void *)2);
    check_ptr_parameter("IVRRenderModels_006_LoadTexture_Async", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_006_LoadTexture_Async", 1);
    check_ptr_parameter("IVRRenderModels_006_LoadTexture_Async", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_FreeTexture, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRRenderModels_006_FreeTexture)(RenderModel_TextureMap_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_FreeTexture((void *)1);
    check_ptr_parameter("IVRRenderModels_006_FreeTexture", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_FreeTexture", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_LoadTextureD3D11_Async, 3, FALSE, FALSE);
    EVRRenderModelError (__stdcall *capi_IVRRenderModels_006_LoadTextureD3D11_Async)(TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_LoadTextureD3D11_Async(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRRenderModels_006_LoadTextureD3D11_Async", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_006_LoadTextureD3D11_Async", 1);
    check_ptr_parameter("IVRRenderModels_006_LoadTextureD3D11_Async", (void *)2);
    check_ptr_parameter("IVRRenderModels_006_LoadTextureD3D11_Async", (void *)3);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_LoadIntoTextureD3D11_Async, 2, FALSE, FALSE);
    EVRRenderModelError (__stdcall *capi_IVRRenderModels_006_LoadIntoTextureD3D11_Async)(TextureID_t textureId, void * pDstTexture) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_LoadIntoTextureD3D11_Async(1, (void *)2);
    check_ptr_parameter("IVRRenderModels_006_LoadIntoTextureD3D11_Async", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_006_LoadIntoTextureD3D11_Async", 1);
    check_ptr_parameter("IVRRenderModels_006_LoadIntoTextureD3D11_Async", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_FreeTextureD3D11, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRRenderModels_006_FreeTextureD3D11)(void * pD3D11Texture2D) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_FreeTextureD3D11((void *)1);
    check_ptr_parameter("IVRRenderModels_006_FreeTextureD3D11", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_FreeTextureD3D11", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_GetRenderModelName, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_006_GetRenderModelName)(uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_GetRenderModelName(1, (void *)2, 3);
    check_ptr_parameter("IVRRenderModels_006_GetRenderModelName", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_006_GetRenderModelName", 1);
    check_ptr_parameter("IVRRenderModels_006_GetRenderModelName", (void *)2);
    check_uint32_parameter("IVRRenderModels_006_GetRenderModelName", 3);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_GetRenderModelCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_006_GetRenderModelCount)() = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_GetRenderModelCount();
    check_ptr_parameter("IVRRenderModels_006_GetRenderModelCount", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_GetComponentCount, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_006_GetComponentCount)(const char * pchRenderModelName) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_GetComponentCount((void *)1);
    check_ptr_parameter("IVRRenderModels_006_GetComponentCount", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_GetComponentCount", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_GetComponentName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_006_GetComponentName)(const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_GetComponentName((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRRenderModels_006_GetComponentName", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_GetComponentName", (void *)1);
    check_uint32_parameter("IVRRenderModels_006_GetComponentName", 2);
    check_ptr_parameter("IVRRenderModels_006_GetComponentName", (void *)3);
    check_uint32_parameter("IVRRenderModels_006_GetComponentName", 4);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_GetComponentButtonMask, 2, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRRenderModels_006_GetComponentButtonMask)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_GetComponentButtonMask((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_006_GetComponentButtonMask", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_GetComponentButtonMask", (void *)1);
    check_ptr_parameter("IVRRenderModels_006_GetComponentButtonMask", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_GetComponentRenderModelName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_006_GetComponentRenderModelName)(const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_GetComponentRenderModelName((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRRenderModels_006_GetComponentRenderModelName", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_GetComponentRenderModelName", (void *)1);
    check_ptr_parameter("IVRRenderModels_006_GetComponentRenderModelName", (void *)2);
    check_ptr_parameter("IVRRenderModels_006_GetComponentRenderModelName", (void *)3);
    check_uint32_parameter("IVRRenderModels_006_GetComponentRenderModelName", 4);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_GetComponentStateForDevicePath, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRRenderModels_006_GetComponentStateForDevicePath)(const char * pchRenderModelName, const char * pchComponentName, VRInputValueHandle_t devicePath, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_GetComponentStateForDevicePath((void *)1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVRRenderModels_006_GetComponentStateForDevicePath", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_GetComponentStateForDevicePath", (void *)1);
    check_ptr_parameter("IVRRenderModels_006_GetComponentStateForDevicePath", (void *)2);
    check_uint64_parameter("IVRRenderModels_006_GetComponentStateForDevicePath", 3);
    check_ptr_parameter("IVRRenderModels_006_GetComponentStateForDevicePath", (void *)4);
    check_ptr_parameter("IVRRenderModels_006_GetComponentStateForDevicePath", (void *)5);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_GetComponentState, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRRenderModels_006_GetComponentState)(const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_GetComponentState((void *)1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRRenderModels_006_GetComponentState", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_GetComponentState", (void *)1);
    check_ptr_parameter("IVRRenderModels_006_GetComponentState", (void *)2);
    check_ptr_parameter("IVRRenderModels_006_GetComponentState", (void *)3);
    check_ptr_parameter("IVRRenderModels_006_GetComponentState", (void *)4);
    check_ptr_parameter("IVRRenderModels_006_GetComponentState", (void *)5);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_RenderModelHasComponent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRRenderModels_006_RenderModelHasComponent)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_RenderModelHasComponent((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_006_RenderModelHasComponent", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_RenderModelHasComponent", (void *)1);
    check_ptr_parameter("IVRRenderModels_006_RenderModelHasComponent", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_GetRenderModelThumbnailURL, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_006_GetRenderModelThumbnailURL)(const char * pchRenderModelName, char * pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError * peError) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_GetRenderModelThumbnailURL((void *)1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRRenderModels_006_GetRenderModelThumbnailURL", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_GetRenderModelThumbnailURL", (void *)1);
    check_ptr_parameter("IVRRenderModels_006_GetRenderModelThumbnailURL", (void *)2);
    check_uint32_parameter("IVRRenderModels_006_GetRenderModelThumbnailURL", 3);
    check_ptr_parameter("IVRRenderModels_006_GetRenderModelThumbnailURL", (void *)4);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_GetRenderModelOriginalPath, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_006_GetRenderModelOriginalPath)(const char * pchRenderModelName, char * pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError * peError) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_GetRenderModelOriginalPath((void *)1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRRenderModels_006_GetRenderModelOriginalPath", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_006_GetRenderModelOriginalPath", (void *)1);
    check_ptr_parameter("IVRRenderModels_006_GetRenderModelOriginalPath", (void *)2);
    check_uint32_parameter("IVRRenderModels_006_GetRenderModelOriginalPath", 3);
    check_ptr_parameter("IVRRenderModels_006_GetRenderModelOriginalPath", (void *)4);

    init_thunk(t, this_ptr_value, IVRRenderModels_006_GetRenderModelErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRRenderModels_006_GetRenderModelErrorNameFromEnum)(EVRRenderModelError error) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_006_GetRenderModelErrorNameFromEnum(1);
    check_ptr_parameter("IVRRenderModels_006_GetRenderModelErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_006_GetRenderModelErrorNameFromEnum", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRExtendedDisplay_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRExtendedDisplay_001_GetWindowBounds, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRExtendedDisplay_001_GetWindowBounds)(int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRExtendedDisplay_001_GetWindowBounds((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVRExtendedDisplay_001_GetWindowBounds", this_ptr_value);
    check_ptr_parameter("IVRExtendedDisplay_001_GetWindowBounds", (void *)1);
    check_ptr_parameter("IVRExtendedDisplay_001_GetWindowBounds", (void *)2);
    check_ptr_parameter("IVRExtendedDisplay_001_GetWindowBounds", (void *)3);
    check_ptr_parameter("IVRExtendedDisplay_001_GetWindowBounds", (void *)4);

    init_thunk(t, this_ptr_value, IVRExtendedDisplay_001_GetEyeOutputViewport, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRExtendedDisplay_001_GetEyeOutputViewport)(EVREye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRExtendedDisplay_001_GetEyeOutputViewport(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRExtendedDisplay_001_GetEyeOutputViewport", this_ptr_value);
    check_uint32_parameter("IVRExtendedDisplay_001_GetEyeOutputViewport", 1);
    check_ptr_parameter("IVRExtendedDisplay_001_GetEyeOutputViewport", (void *)2);
    check_ptr_parameter("IVRExtendedDisplay_001_GetEyeOutputViewport", (void *)3);
    check_ptr_parameter("IVRExtendedDisplay_001_GetEyeOutputViewport", (void *)4);
    check_ptr_parameter("IVRExtendedDisplay_001_GetEyeOutputViewport", (void *)5);

    init_thunk(t, this_ptr_value, IVRExtendedDisplay_001_GetDXGIOutputInfo, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRExtendedDisplay_001_GetDXGIOutputInfo)(int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex) = (void *)t;

    clear_parameters();
    capi_IVRExtendedDisplay_001_GetDXGIOutputInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRExtendedDisplay_001_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRExtendedDisplay_001_GetDXGIOutputInfo", (void *)1);
    check_ptr_parameter("IVRExtendedDisplay_001_GetDXGIOutputInfo", (void *)2);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRTrackedCamera_006(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_GetCameraErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRTrackedCamera_006_GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_GetCameraErrorNameFromEnum(1);
    check_ptr_parameter("IVRTrackedCamera_006_GetCameraErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_006_GetCameraErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_HasCamera, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_006_HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_HasCamera(1, (void *)2);
    check_ptr_parameter("IVRTrackedCamera_006_HasCamera", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_006_HasCamera", 1);
    check_ptr_parameter("IVRTrackedCamera_006_HasCamera", (void *)2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_GetCameraFrameSize, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_006_GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_GetCameraFrameSize(1, 2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_006_GetCameraFrameSize", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_006_GetCameraFrameSize", 1);
    check_uint32_parameter("IVRTrackedCamera_006_GetCameraFrameSize", 2);
    check_ptr_parameter("IVRTrackedCamera_006_GetCameraFrameSize", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_006_GetCameraFrameSize", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_006_GetCameraFrameSize", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_GetCameraIntrinsics, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_006_GetCameraIntrinsics)(TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_GetCameraIntrinsics(1, 2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_006_GetCameraIntrinsics", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_006_GetCameraIntrinsics", 1);
    check_uint32_parameter("IVRTrackedCamera_006_GetCameraIntrinsics", 2);
    check_uint32_parameter("IVRTrackedCamera_006_GetCameraIntrinsics", 3);
    check_ptr_parameter("IVRTrackedCamera_006_GetCameraIntrinsics", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_006_GetCameraIntrinsics", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_GetCameraProjection, 6, TRUE, TRUE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_006_GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_GetCameraProjection(1, 2, 3, 4.0f, 5.0f, (void *)6);
    check_ptr_parameter("IVRTrackedCamera_006_GetCameraProjection", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_006_GetCameraProjection", 1);
    check_uint32_parameter("IVRTrackedCamera_006_GetCameraProjection", 2);
    check_uint32_parameter("IVRTrackedCamera_006_GetCameraProjection", 3);
    check_float_parameter("IVRTrackedCamera_006_GetCameraProjection", 4.0f);
    check_float_parameter("IVRTrackedCamera_006_GetCameraProjection", 5.0f);
    check_ptr_parameter("IVRTrackedCamera_006_GetCameraProjection", (void *)6);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_AcquireVideoStreamingService, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_006_AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_AcquireVideoStreamingService(1, (void *)2);
    check_ptr_parameter("IVRTrackedCamera_006_AcquireVideoStreamingService", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_006_AcquireVideoStreamingService", 1);
    check_ptr_parameter("IVRTrackedCamera_006_AcquireVideoStreamingService", (void *)2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_ReleaseVideoStreamingService, 1, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_006_ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_ReleaseVideoStreamingService(1);
    check_ptr_parameter("IVRTrackedCamera_006_ReleaseVideoStreamingService", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_006_ReleaseVideoStreamingService", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_GetVideoStreamFrameBuffer, 6, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_006_GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(1, 2, (void *)3, 4, (void *)5, 6);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamFrameBuffer", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_006_GetVideoStreamFrameBuffer", 1);
    check_uint32_parameter("IVRTrackedCamera_006_GetVideoStreamFrameBuffer", 2);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamFrameBuffer", (void *)3);
    check_uint32_parameter("IVRTrackedCamera_006_GetVideoStreamFrameBuffer", 4);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamFrameBuffer", (void *)5);
    check_uint32_parameter("IVRTrackedCamera_006_GetVideoStreamFrameBuffer", 6);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_GetVideoStreamTextureSize, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_006_GetVideoStreamTextureSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_GetVideoStreamTextureSize(1, 2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamTextureSize", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_006_GetVideoStreamTextureSize", 1);
    check_uint32_parameter("IVRTrackedCamera_006_GetVideoStreamTextureSize", 2);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamTextureSize", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamTextureSize", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamTextureSize", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_GetVideoStreamTextureD3D11, 6, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_006_GetVideoStreamTextureD3D11)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(1, 2, (void *)3, (void *)4, (void *)5, 6);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamTextureD3D11", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_006_GetVideoStreamTextureD3D11", 1);
    check_uint32_parameter("IVRTrackedCamera_006_GetVideoStreamTextureD3D11", 2);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamTextureD3D11", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamTextureD3D11", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamTextureD3D11", (void *)5);
    check_uint32_parameter("IVRTrackedCamera_006_GetVideoStreamTextureD3D11", 6);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_GetVideoStreamTextureGL, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_006_GetVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_GetVideoStreamTextureGL(1, 2, (void *)3, (void *)4, 5);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamTextureGL", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_006_GetVideoStreamTextureGL", 1);
    check_uint32_parameter("IVRTrackedCamera_006_GetVideoStreamTextureGL", 2);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamTextureGL", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_006_GetVideoStreamTextureGL", (void *)4);
    check_uint32_parameter("IVRTrackedCamera_006_GetVideoStreamTextureGL", 5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_ReleaseVideoStreamTextureGL, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_006_ReleaseVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_ReleaseVideoStreamTextureGL(1, 2);
    check_ptr_parameter("IVRTrackedCamera_006_ReleaseVideoStreamTextureGL", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_006_ReleaseVideoStreamTextureGL", 1);
    check_uint32_parameter("IVRTrackedCamera_006_ReleaseVideoStreamTextureGL", 2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_SetCameraTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRTrackedCamera_006_SetCameraTrackingSpace)(ETrackingUniverseOrigin eUniverse) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_SetCameraTrackingSpace(1);
    check_ptr_parameter("IVRTrackedCamera_006_SetCameraTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_006_SetCameraTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_006_GetCameraTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRTrackedCamera_006_GetCameraTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_006_GetCameraTrackingSpace();
    check_ptr_parameter("IVRTrackedCamera_006_GetCameraTrackingSpace", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRScreenshots_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRScreenshots_001_RequestScreenshot, 4, FALSE, FALSE);
    EVRScreenshotError (__stdcall *capi_IVRScreenshots_001_RequestScreenshot)(ScreenshotHandle_t * pOutScreenshotHandle, EVRScreenshotType type, const char * pchPreviewFilename, const char * pchVRFilename) = (void *)t;

    clear_parameters();
    capi_IVRScreenshots_001_RequestScreenshot((void *)1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRScreenshots_001_RequestScreenshot", this_ptr_value);
    check_ptr_parameter("IVRScreenshots_001_RequestScreenshot", (void *)1);
    check_uint32_parameter("IVRScreenshots_001_RequestScreenshot", 2);
    check_ptr_parameter("IVRScreenshots_001_RequestScreenshot", (void *)3);
    check_ptr_parameter("IVRScreenshots_001_RequestScreenshot", (void *)4);

    init_thunk(t, this_ptr_value, IVRScreenshots_001_HookScreenshot, 2, FALSE, FALSE);
    EVRScreenshotError (__stdcall *capi_IVRScreenshots_001_HookScreenshot)(EVRScreenshotType * pSupportedTypes, int numTypes) = (void *)t;

    clear_parameters();
    capi_IVRScreenshots_001_HookScreenshot((void *)1, 2);
    check_ptr_parameter("IVRScreenshots_001_HookScreenshot", this_ptr_value);
    check_ptr_parameter("IVRScreenshots_001_HookScreenshot", (void *)1);
    check_uint32_parameter("IVRScreenshots_001_HookScreenshot", 2);

    init_thunk(t, this_ptr_value, IVRScreenshots_001_GetScreenshotPropertyType, 2, FALSE, FALSE);
    EVRScreenshotType (__stdcall *capi_IVRScreenshots_001_GetScreenshotPropertyType)(ScreenshotHandle_t screenshotHandle, EVRScreenshotError * pError) = (void *)t;

    clear_parameters();
    capi_IVRScreenshots_001_GetScreenshotPropertyType(1, (void *)2);
    check_ptr_parameter("IVRScreenshots_001_GetScreenshotPropertyType", this_ptr_value);
    check_uint32_parameter("IVRScreenshots_001_GetScreenshotPropertyType", 1);
    check_ptr_parameter("IVRScreenshots_001_GetScreenshotPropertyType", (void *)2);

    init_thunk(t, this_ptr_value, IVRScreenshots_001_GetScreenshotPropertyFilename, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRScreenshots_001_GetScreenshotPropertyFilename)(ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char * pchFilename, uint32_t cchFilename, EVRScreenshotError * pError) = (void *)t;

    clear_parameters();
    capi_IVRScreenshots_001_GetScreenshotPropertyFilename(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRScreenshots_001_GetScreenshotPropertyFilename", this_ptr_value);
    check_uint32_parameter("IVRScreenshots_001_GetScreenshotPropertyFilename", 1);
    check_uint32_parameter("IVRScreenshots_001_GetScreenshotPropertyFilename", 2);
    check_ptr_parameter("IVRScreenshots_001_GetScreenshotPropertyFilename", (void *)3);
    check_uint32_parameter("IVRScreenshots_001_GetScreenshotPropertyFilename", 4);
    check_ptr_parameter("IVRScreenshots_001_GetScreenshotPropertyFilename", (void *)5);

    init_thunk(t, this_ptr_value, IVRScreenshots_001_UpdateScreenshotProgress, 2, TRUE, FALSE);
    EVRScreenshotError (__stdcall *capi_IVRScreenshots_001_UpdateScreenshotProgress)(ScreenshotHandle_t screenshotHandle, float flProgress) = (void *)t;

    clear_parameters();
    capi_IVRScreenshots_001_UpdateScreenshotProgress(1, 2.0f);
    check_ptr_parameter("IVRScreenshots_001_UpdateScreenshotProgress", this_ptr_value);
    check_uint32_parameter("IVRScreenshots_001_UpdateScreenshotProgress", 1);
    check_float_parameter("IVRScreenshots_001_UpdateScreenshotProgress", 2.0f);

    init_thunk(t, this_ptr_value, IVRScreenshots_001_TakeStereoScreenshot, 3, FALSE, FALSE);
    EVRScreenshotError (__stdcall *capi_IVRScreenshots_001_TakeStereoScreenshot)(ScreenshotHandle_t * pOutScreenshotHandle, const char * pchPreviewFilename, const char * pchVRFilename) = (void *)t;

    clear_parameters();
    capi_IVRScreenshots_001_TakeStereoScreenshot((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRScreenshots_001_TakeStereoScreenshot", this_ptr_value);
    check_ptr_parameter("IVRScreenshots_001_TakeStereoScreenshot", (void *)1);
    check_ptr_parameter("IVRScreenshots_001_TakeStereoScreenshot", (void *)2);
    check_ptr_parameter("IVRScreenshots_001_TakeStereoScreenshot", (void *)3);

    init_thunk(t, this_ptr_value, IVRScreenshots_001_SubmitScreenshot, 4, FALSE, FALSE);
    EVRScreenshotError (__stdcall *capi_IVRScreenshots_001_SubmitScreenshot)(ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, const char * pchSourcePreviewFilename, const char * pchSourceVRFilename) = (void *)t;

    clear_parameters();
    capi_IVRScreenshots_001_SubmitScreenshot(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRScreenshots_001_SubmitScreenshot", this_ptr_value);
    check_uint32_parameter("IVRScreenshots_001_SubmitScreenshot", 1);
    check_uint32_parameter("IVRScreenshots_001_SubmitScreenshot", 2);
    check_ptr_parameter("IVRScreenshots_001_SubmitScreenshot", (void *)3);
    check_ptr_parameter("IVRScreenshots_001_SubmitScreenshot", (void *)4);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRResources_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRResources_001_LoadSharedResource, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRResources_001_LoadSharedResource)(const char * pchResourceName, char * pchBuffer, uint32_t unBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRResources_001_LoadSharedResource((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRResources_001_LoadSharedResource", this_ptr_value);
    check_ptr_parameter("IVRResources_001_LoadSharedResource", (void *)1);
    check_ptr_parameter("IVRResources_001_LoadSharedResource", (void *)2);
    check_uint32_parameter("IVRResources_001_LoadSharedResource", 3);

    init_thunk(t, this_ptr_value, IVRResources_001_GetResourceFullPath, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRResources_001_GetResourceFullPath)(const char * pchResourceName, const char * pchResourceTypeDirectory, char * pchPathBuffer, uint32_t unBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRResources_001_GetResourceFullPath((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRResources_001_GetResourceFullPath", this_ptr_value);
    check_ptr_parameter("IVRResources_001_GetResourceFullPath", (void *)1);
    check_ptr_parameter("IVRResources_001_GetResourceFullPath", (void *)2);
    check_ptr_parameter("IVRResources_001_GetResourceFullPath", (void *)3);
    check_uint32_parameter("IVRResources_001_GetResourceFullPath", 4);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRDriverManager_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRDriverManager_001_GetDriverCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRDriverManager_001_GetDriverCount)() = (void *)t;

    clear_parameters();
    capi_IVRDriverManager_001_GetDriverCount();
    check_ptr_parameter("IVRDriverManager_001_GetDriverCount", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRDriverManager_001_GetDriverName, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRDriverManager_001_GetDriverName)(DriverId_t nDriver, char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRDriverManager_001_GetDriverName(1, (void *)2, 3);
    check_ptr_parameter("IVRDriverManager_001_GetDriverName", this_ptr_value);
    check_uint32_parameter("IVRDriverManager_001_GetDriverName", 1);
    check_ptr_parameter("IVRDriverManager_001_GetDriverName", (void *)2);
    check_uint32_parameter("IVRDriverManager_001_GetDriverName", 3);

    init_thunk(t, this_ptr_value, IVRDriverManager_001_GetDriverHandle, 1, FALSE, FALSE);
    DriverHandle_t (__stdcall *capi_IVRDriverManager_001_GetDriverHandle)(const char * pchDriverName) = (void *)t;

    clear_parameters();
    capi_IVRDriverManager_001_GetDriverHandle((void *)1);
    check_ptr_parameter("IVRDriverManager_001_GetDriverHandle", this_ptr_value);
    check_ptr_parameter("IVRDriverManager_001_GetDriverHandle", (void *)1);

    init_thunk(t, this_ptr_value, IVRDriverManager_001_IsEnabled, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRDriverManager_001_IsEnabled)(DriverId_t nDriver) = (void *)t;

    clear_parameters();
    capi_IVRDriverManager_001_IsEnabled(1);
    check_ptr_parameter("IVRDriverManager_001_IsEnabled", this_ptr_value);
    check_uint32_parameter("IVRDriverManager_001_IsEnabled", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRInput_010(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRInput_010_SetActionManifestPath, 1, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_SetActionManifestPath)(const char * pchActionManifestPath) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_SetActionManifestPath((void *)1);
    check_ptr_parameter("IVRInput_010_SetActionManifestPath", this_ptr_value);
    check_ptr_parameter("IVRInput_010_SetActionManifestPath", (void *)1);

    init_thunk(t, this_ptr_value, IVRInput_010_GetActionSetHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetActionSetHandle)(const char * pchActionSetName, VRActionSetHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetActionSetHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_010_GetActionSetHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_010_GetActionSetHandle", (void *)1);
    check_ptr_parameter("IVRInput_010_GetActionSetHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_010_GetActionHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetActionHandle)(const char * pchActionName, VRActionHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetActionHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_010_GetActionHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_010_GetActionHandle", (void *)1);
    check_ptr_parameter("IVRInput_010_GetActionHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_010_GetInputSourceHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetInputSourceHandle)(const char * pchInputSourcePath, VRInputValueHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetInputSourceHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_010_GetInputSourceHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_010_GetInputSourceHandle", (void *)1);
    check_ptr_parameter("IVRInput_010_GetInputSourceHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_010_UpdateActionState, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_UpdateActionState)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_UpdateActionState((void *)1, 2, 3);
    check_ptr_parameter("IVRInput_010_UpdateActionState", this_ptr_value);
    check_ptr_parameter("IVRInput_010_UpdateActionState", (void *)1);
    check_uint32_parameter("IVRInput_010_UpdateActionState", 2);
    check_uint32_parameter("IVRInput_010_UpdateActionState", 3);

    init_thunk(t, this_ptr_value, IVRInput_010_GetDigitalActionData, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetDigitalActionData)(VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetDigitalActionData(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_010_GetDigitalActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetDigitalActionData", 1);
    check_ptr_parameter("IVRInput_010_GetDigitalActionData", (void *)2);
    check_uint32_parameter("IVRInput_010_GetDigitalActionData", 3);
    check_uint64_parameter("IVRInput_010_GetDigitalActionData", 4);

    init_thunk(t, this_ptr_value, IVRInput_010_GetAnalogActionData, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetAnalogActionData)(VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetAnalogActionData(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_010_GetAnalogActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetAnalogActionData", 1);
    check_ptr_parameter("IVRInput_010_GetAnalogActionData", (void *)2);
    check_uint32_parameter("IVRInput_010_GetAnalogActionData", 3);
    check_uint64_parameter("IVRInput_010_GetAnalogActionData", 4);

    init_thunk(t, this_ptr_value, IVRInput_010_GetPoseActionDataRelativeToNow, 6, TRUE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetPoseActionDataRelativeToNow)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetPoseActionDataRelativeToNow(1, 2, 3.0f, (void *)4, 5, 6);
    check_ptr_parameter("IVRInput_010_GetPoseActionDataRelativeToNow", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetPoseActionDataRelativeToNow", 1);
    check_uint32_parameter("IVRInput_010_GetPoseActionDataRelativeToNow", 2);
    check_float_parameter("IVRInput_010_GetPoseActionDataRelativeToNow", 3.0f);
    check_ptr_parameter("IVRInput_010_GetPoseActionDataRelativeToNow", (void *)4);
    check_uint32_parameter("IVRInput_010_GetPoseActionDataRelativeToNow", 5);
    check_uint64_parameter("IVRInput_010_GetPoseActionDataRelativeToNow", 6);

    init_thunk(t, this_ptr_value, IVRInput_010_GetPoseActionDataForNextFrame, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetPoseActionDataForNextFrame)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetPoseActionDataForNextFrame(1, 2, (void *)3, 4, 5);
    check_ptr_parameter("IVRInput_010_GetPoseActionDataForNextFrame", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetPoseActionDataForNextFrame", 1);
    check_uint32_parameter("IVRInput_010_GetPoseActionDataForNextFrame", 2);
    check_ptr_parameter("IVRInput_010_GetPoseActionDataForNextFrame", (void *)3);
    check_uint32_parameter("IVRInput_010_GetPoseActionDataForNextFrame", 4);
    check_uint64_parameter("IVRInput_010_GetPoseActionDataForNextFrame", 5);

    init_thunk(t, this_ptr_value, IVRInput_010_GetSkeletalActionData, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetSkeletalActionData)(VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetSkeletalActionData(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_010_GetSkeletalActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetSkeletalActionData", 1);
    check_ptr_parameter("IVRInput_010_GetSkeletalActionData", (void *)2);
    check_uint32_parameter("IVRInput_010_GetSkeletalActionData", 3);

    init_thunk(t, this_ptr_value, IVRInput_010_GetDominantHand, 1, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetDominantHand)(ETrackedControllerRole * peDominantHand) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetDominantHand((void *)1);
    check_ptr_parameter("IVRInput_010_GetDominantHand", this_ptr_value);
    check_ptr_parameter("IVRInput_010_GetDominantHand", (void *)1);

    init_thunk(t, this_ptr_value, IVRInput_010_SetDominantHand, 1, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_SetDominantHand)(ETrackedControllerRole eDominantHand) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_SetDominantHand(1);
    check_ptr_parameter("IVRInput_010_SetDominantHand", this_ptr_value);
    check_uint32_parameter("IVRInput_010_SetDominantHand", 1);

    init_thunk(t, this_ptr_value, IVRInput_010_GetBoneCount, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetBoneCount)(VRActionHandle_t action, uint32_t * pBoneCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetBoneCount(1, (void *)2);
    check_ptr_parameter("IVRInput_010_GetBoneCount", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetBoneCount", 1);
    check_ptr_parameter("IVRInput_010_GetBoneCount", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_010_GetBoneHierarchy, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetBoneHierarchy)(VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetBoneHierarchy(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_010_GetBoneHierarchy", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetBoneHierarchy", 1);
    check_ptr_parameter("IVRInput_010_GetBoneHierarchy", (void *)2);
    check_uint32_parameter("IVRInput_010_GetBoneHierarchy", 3);

    init_thunk(t, this_ptr_value, IVRInput_010_GetBoneName, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetBoneName)(VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetBoneName(1, 2, (void *)3, 4);
    check_ptr_parameter("IVRInput_010_GetBoneName", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetBoneName", 1);
    check_uint32_parameter("IVRInput_010_GetBoneName", 2);
    check_ptr_parameter("IVRInput_010_GetBoneName", (void *)3);
    check_uint32_parameter("IVRInput_010_GetBoneName", 4);

    init_thunk(t, this_ptr_value, IVRInput_010_GetSkeletalReferenceTransforms, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetSkeletalReferenceTransforms)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetSkeletalReferenceTransforms(1, 2, 3, (void *)4, 5);
    check_ptr_parameter("IVRInput_010_GetSkeletalReferenceTransforms", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetSkeletalReferenceTransforms", 1);
    check_uint32_parameter("IVRInput_010_GetSkeletalReferenceTransforms", 2);
    check_uint32_parameter("IVRInput_010_GetSkeletalReferenceTransforms", 3);
    check_ptr_parameter("IVRInput_010_GetSkeletalReferenceTransforms", (void *)4);
    check_uint32_parameter("IVRInput_010_GetSkeletalReferenceTransforms", 5);

    init_thunk(t, this_ptr_value, IVRInput_010_GetSkeletalTrackingLevel, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetSkeletalTrackingLevel)(VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetSkeletalTrackingLevel(1, (void *)2);
    check_ptr_parameter("IVRInput_010_GetSkeletalTrackingLevel", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetSkeletalTrackingLevel", 1);
    check_ptr_parameter("IVRInput_010_GetSkeletalTrackingLevel", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_010_GetSkeletalBoneData, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetSkeletalBoneData)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetSkeletalBoneData(1, 2, 3, (void *)4, 5);
    check_ptr_parameter("IVRInput_010_GetSkeletalBoneData", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetSkeletalBoneData", 1);
    check_uint32_parameter("IVRInput_010_GetSkeletalBoneData", 2);
    check_uint32_parameter("IVRInput_010_GetSkeletalBoneData", 3);
    check_ptr_parameter("IVRInput_010_GetSkeletalBoneData", (void *)4);
    check_uint32_parameter("IVRInput_010_GetSkeletalBoneData", 5);

    init_thunk(t, this_ptr_value, IVRInput_010_GetSkeletalSummaryData, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetSkeletalSummaryData)(VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetSkeletalSummaryData(1, 2, (void *)3);
    check_ptr_parameter("IVRInput_010_GetSkeletalSummaryData", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetSkeletalSummaryData", 1);
    check_uint32_parameter("IVRInput_010_GetSkeletalSummaryData", 2);
    check_ptr_parameter("IVRInput_010_GetSkeletalSummaryData", (void *)3);

    init_thunk(t, this_ptr_value, IVRInput_010_GetSkeletalBoneDataCompressed, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetSkeletalBoneDataCompressed)(VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetSkeletalBoneDataCompressed(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRInput_010_GetSkeletalBoneDataCompressed", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetSkeletalBoneDataCompressed", 1);
    check_uint32_parameter("IVRInput_010_GetSkeletalBoneDataCompressed", 2);
    check_ptr_parameter("IVRInput_010_GetSkeletalBoneDataCompressed", (void *)3);
    check_uint32_parameter("IVRInput_010_GetSkeletalBoneDataCompressed", 4);
    check_ptr_parameter("IVRInput_010_GetSkeletalBoneDataCompressed", (void *)5);

    init_thunk(t, this_ptr_value, IVRInput_010_DecompressSkeletalBoneData, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_DecompressSkeletalBoneData)(const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_DecompressSkeletalBoneData((void *)1, 2, 3, (void *)4, 5);
    check_ptr_parameter("IVRInput_010_DecompressSkeletalBoneData", this_ptr_value);
    check_ptr_parameter("IVRInput_010_DecompressSkeletalBoneData", (void *)1);
    check_uint32_parameter("IVRInput_010_DecompressSkeletalBoneData", 2);
    check_uint32_parameter("IVRInput_010_DecompressSkeletalBoneData", 3);
    check_ptr_parameter("IVRInput_010_DecompressSkeletalBoneData", (void *)4);
    check_uint32_parameter("IVRInput_010_DecompressSkeletalBoneData", 5);

    init_thunk(t, this_ptr_value, IVRInput_010_TriggerHapticVibrationAction, 6, TRUE, TRUE);
    EVRInputError (__stdcall *capi_IVRInput_010_TriggerHapticVibrationAction)(VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_TriggerHapticVibrationAction(1, 2.0f, 3.0f, 4.0f, 5.0f, 6);
    check_ptr_parameter("IVRInput_010_TriggerHapticVibrationAction", this_ptr_value);
    check_uint64_parameter("IVRInput_010_TriggerHapticVibrationAction", 1);
    check_float_parameter("IVRInput_010_TriggerHapticVibrationAction", 2.0f);
    check_float_parameter("IVRInput_010_TriggerHapticVibrationAction", 3.0f);
    check_float_parameter("IVRInput_010_TriggerHapticVibrationAction", 4.0f);
    check_float_parameter("IVRInput_010_TriggerHapticVibrationAction", 5.0f);
    check_uint64_parameter("IVRInput_010_TriggerHapticVibrationAction", 6);

    init_thunk(t, this_ptr_value, IVRInput_010_GetActionOrigins, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetActionOrigins(1, 2, (void *)3, 4);
    check_ptr_parameter("IVRInput_010_GetActionOrigins", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetActionOrigins", 1);
    check_uint64_parameter("IVRInput_010_GetActionOrigins", 2);
    check_ptr_parameter("IVRInput_010_GetActionOrigins", (void *)3);
    check_uint32_parameter("IVRInput_010_GetActionOrigins", 4);

    init_thunk(t, this_ptr_value, IVRInput_010_GetOriginLocalizedName, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetOriginLocalizedName)(VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetOriginLocalizedName(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_010_GetOriginLocalizedName", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetOriginLocalizedName", 1);
    check_ptr_parameter("IVRInput_010_GetOriginLocalizedName", (void *)2);
    check_uint32_parameter("IVRInput_010_GetOriginLocalizedName", 3);
    check_uint32_parameter("IVRInput_010_GetOriginLocalizedName", 4);

    init_thunk(t, this_ptr_value, IVRInput_010_GetOriginTrackedDeviceInfo, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetOriginTrackedDeviceInfo)(VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetOriginTrackedDeviceInfo(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_010_GetOriginTrackedDeviceInfo", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetOriginTrackedDeviceInfo", 1);
    check_ptr_parameter("IVRInput_010_GetOriginTrackedDeviceInfo", (void *)2);
    check_uint32_parameter("IVRInput_010_GetOriginTrackedDeviceInfo", 3);

    init_thunk(t, this_ptr_value, IVRInput_010_GetActionBindingInfo, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetActionBindingInfo)(VRActionHandle_t action, InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t * punReturnedBindingInfoCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetActionBindingInfo(1, (void *)2, 3, 4, (void *)5);
    check_ptr_parameter("IVRInput_010_GetActionBindingInfo", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetActionBindingInfo", 1);
    check_ptr_parameter("IVRInput_010_GetActionBindingInfo", (void *)2);
    check_uint32_parameter("IVRInput_010_GetActionBindingInfo", 3);
    check_uint32_parameter("IVRInput_010_GetActionBindingInfo", 4);
    check_ptr_parameter("IVRInput_010_GetActionBindingInfo", (void *)5);

    init_thunk(t, this_ptr_value, IVRInput_010_ShowActionOrigins, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_ShowActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_ShowActionOrigins(1, 2);
    check_ptr_parameter("IVRInput_010_ShowActionOrigins", this_ptr_value);
    check_uint64_parameter("IVRInput_010_ShowActionOrigins", 1);
    check_uint64_parameter("IVRInput_010_ShowActionOrigins", 2);

    init_thunk(t, this_ptr_value, IVRInput_010_ShowBindingsForActionSet, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_ShowBindingsForActionSet)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_ShowBindingsForActionSet((void *)1, 2, 3, 4);
    check_ptr_parameter("IVRInput_010_ShowBindingsForActionSet", this_ptr_value);
    check_ptr_parameter("IVRInput_010_ShowBindingsForActionSet", (void *)1);
    check_uint32_parameter("IVRInput_010_ShowBindingsForActionSet", 2);
    check_uint32_parameter("IVRInput_010_ShowBindingsForActionSet", 3);
    check_uint64_parameter("IVRInput_010_ShowBindingsForActionSet", 4);

    init_thunk(t, this_ptr_value, IVRInput_010_GetComponentStateForBinding, 6, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetComponentStateForBinding)(const char * pchRenderModelName, const char * pchComponentName, InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, RenderModel_ComponentState_t * pComponentState) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetComponentStateForBinding((void *)1, (void *)2, (void *)3, 4, 5, (void *)6);
    check_ptr_parameter("IVRInput_010_GetComponentStateForBinding", this_ptr_value);
    check_ptr_parameter("IVRInput_010_GetComponentStateForBinding", (void *)1);
    check_ptr_parameter("IVRInput_010_GetComponentStateForBinding", (void *)2);
    check_ptr_parameter("IVRInput_010_GetComponentStateForBinding", (void *)3);
    check_uint32_parameter("IVRInput_010_GetComponentStateForBinding", 4);
    check_uint32_parameter("IVRInput_010_GetComponentStateForBinding", 5);
    check_ptr_parameter("IVRInput_010_GetComponentStateForBinding", (void *)6);

    init_thunk(t, this_ptr_value, IVRInput_010_IsUsingLegacyInput, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRInput_010_IsUsingLegacyInput)() = (void *)t;

    clear_parameters();
    capi_IVRInput_010_IsUsingLegacyInput();
    check_ptr_parameter("IVRInput_010_IsUsingLegacyInput", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRInput_010_OpenBindingUI, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_OpenBindingUI)(const char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_OpenBindingUI((void *)1, 2, 3, 1);
    check_ptr_parameter("IVRInput_010_OpenBindingUI", this_ptr_value);
    check_ptr_parameter("IVRInput_010_OpenBindingUI", (void *)1);
    check_uint64_parameter("IVRInput_010_OpenBindingUI", 2);
    check_uint64_parameter("IVRInput_010_OpenBindingUI", 3);
    check_bool_parameter("IVRInput_010_OpenBindingUI", 1);

    init_thunk(t, this_ptr_value, IVRInput_010_GetBindingVariant, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_010_GetBindingVariant)(VRInputValueHandle_t ulDevicePath, char * pchVariantArray, uint32_t unVariantArraySize) = (void *)t;

    clear_parameters();
    capi_IVRInput_010_GetBindingVariant(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_010_GetBindingVariant", this_ptr_value);
    check_uint64_parameter("IVRInput_010_GetBindingVariant", 1);
    check_ptr_parameter("IVRInput_010_GetBindingVariant", (void *)2);
    check_uint32_parameter("IVRInput_010_GetBindingVariant", 3);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRIOBuffer_002(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRIOBuffer_002_Open, 5, FALSE, FALSE);
    EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Open)(const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer) = (void *)t;

    clear_parameters();
    capi_IVRIOBuffer_002_Open((void *)1, 2, 3, 4, (void *)5);
    check_ptr_parameter("IVRIOBuffer_002_Open", this_ptr_value);
    check_ptr_parameter("IVRIOBuffer_002_Open", (void *)1);
    check_uint32_parameter("IVRIOBuffer_002_Open", 2);
    check_uint32_parameter("IVRIOBuffer_002_Open", 3);
    check_uint32_parameter("IVRIOBuffer_002_Open", 4);
    check_ptr_parameter("IVRIOBuffer_002_Open", (void *)5);

    init_thunk(t, this_ptr_value, IVRIOBuffer_002_Close, 1, FALSE, FALSE);
    EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Close)(IOBufferHandle_t ulBuffer) = (void *)t;

    clear_parameters();
    capi_IVRIOBuffer_002_Close(1);
    check_ptr_parameter("IVRIOBuffer_002_Close", this_ptr_value);
    check_uint64_parameter("IVRIOBuffer_002_Close", 1);

    init_thunk(t, this_ptr_value, IVRIOBuffer_002_Read, 4, FALSE, FALSE);
    EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Read)(IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead) = (void *)t;

    clear_parameters();
    capi_IVRIOBuffer_002_Read(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRIOBuffer_002_Read", this_ptr_value);
    check_uint64_parameter("IVRIOBuffer_002_Read", 1);
    check_ptr_parameter("IVRIOBuffer_002_Read", (void *)2);
    check_uint32_parameter("IVRIOBuffer_002_Read", 3);
    check_ptr_parameter("IVRIOBuffer_002_Read", (void *)4);

    init_thunk(t, this_ptr_value, IVRIOBuffer_002_Write, 3, FALSE, FALSE);
    EIOBufferError (__stdcall *capi_IVRIOBuffer_002_Write)(IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes) = (void *)t;

    clear_parameters();
    capi_IVRIOBuffer_002_Write(1, (void *)2, 3);
    check_ptr_parameter("IVRIOBuffer_002_Write", this_ptr_value);
    check_uint64_parameter("IVRIOBuffer_002_Write", 1);
    check_ptr_parameter("IVRIOBuffer_002_Write", (void *)2);
    check_uint32_parameter("IVRIOBuffer_002_Write", 3);

    init_thunk(t, this_ptr_value, IVRIOBuffer_002_PropertyContainer, 1, FALSE, FALSE);
    PropertyContainerHandle_t (__stdcall *capi_IVRIOBuffer_002_PropertyContainer)(IOBufferHandle_t ulBuffer) = (void *)t;

    clear_parameters();
    capi_IVRIOBuffer_002_PropertyContainer(1);
    check_ptr_parameter("IVRIOBuffer_002_PropertyContainer", this_ptr_value);
    check_uint64_parameter("IVRIOBuffer_002_PropertyContainer", 1);

    init_thunk(t, this_ptr_value, IVRIOBuffer_002_HasReaders, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRIOBuffer_002_HasReaders)(IOBufferHandle_t ulBuffer) = (void *)t;

    clear_parameters();
    capi_IVRIOBuffer_002_HasReaders(1);
    check_ptr_parameter("IVRIOBuffer_002_HasReaders", this_ptr_value);
    check_uint64_parameter("IVRIOBuffer_002_HasReaders", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRClientCore_003(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRClientCore_003_Init, 2, FALSE, FALSE);
    EVRInitError (__stdcall *capi_IVRClientCore_003_Init)(EVRApplicationType eApplicationType, const char * pStartupInfo) = (void *)t;

    clear_parameters();
    capi_IVRClientCore_003_Init(1, (void *)2);
    check_ptr_parameter("IVRClientCore_003_Init", this_ptr_value);
    check_uint32_parameter("IVRClientCore_003_Init", 1);
    check_ptr_parameter("IVRClientCore_003_Init", (void *)2);

    init_thunk(t, this_ptr_value, IVRClientCore_003_Cleanup, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRClientCore_003_Cleanup)() = (void *)t;

    clear_parameters();
    capi_IVRClientCore_003_Cleanup();
    check_ptr_parameter("IVRClientCore_003_Cleanup", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRClientCore_003_IsInterfaceVersionValid, 1, FALSE, FALSE);
    EVRInitError (__stdcall *capi_IVRClientCore_003_IsInterfaceVersionValid)(const char * pchInterfaceVersion) = (void *)t;

    clear_parameters();
    capi_IVRClientCore_003_IsInterfaceVersionValid((void *)1);
    check_ptr_parameter("IVRClientCore_003_IsInterfaceVersionValid", this_ptr_value);
    check_ptr_parameter("IVRClientCore_003_IsInterfaceVersionValid", (void *)1);

    init_thunk(t, this_ptr_value, IVRClientCore_003_GetGenericInterface, 2, FALSE, FALSE);
    void * (__stdcall *capi_IVRClientCore_003_GetGenericInterface)(const char * pchNameAndVersion, EVRInitError * peError) = (void *)t;

    clear_parameters();
    capi_IVRClientCore_003_GetGenericInterface((void *)1, (void *)2);
    check_ptr_parameter("IVRClientCore_003_GetGenericInterface", this_ptr_value);
    check_ptr_parameter("IVRClientCore_003_GetGenericInterface", (void *)1);
    check_ptr_parameter("IVRClientCore_003_GetGenericInterface", (void *)2);

    init_thunk(t, this_ptr_value, IVRClientCore_003_BIsHmdPresent, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRClientCore_003_BIsHmdPresent)() = (void *)t;

    clear_parameters();
    capi_IVRClientCore_003_BIsHmdPresent();
    check_ptr_parameter("IVRClientCore_003_BIsHmdPresent", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRClientCore_003_GetEnglishStringForHmdError, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRClientCore_003_GetEnglishStringForHmdError)(EVRInitError eError) = (void *)t;

    clear_parameters();
    capi_IVRClientCore_003_GetEnglishStringForHmdError(1);
    check_ptr_parameter("IVRClientCore_003_GetEnglishStringForHmdError", this_ptr_value);
    check_uint32_parameter("IVRClientCore_003_GetEnglishStringForHmdError", 1);

    init_thunk(t, this_ptr_value, IVRClientCore_003_GetIDForVRInitError, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRClientCore_003_GetIDForVRInitError)(EVRInitError eError) = (void *)t;

    clear_parameters();
    capi_IVRClientCore_003_GetIDForVRInitError(1);
    check_ptr_parameter("IVRClientCore_003_GetIDForVRInitError", this_ptr_value);
    check_uint32_parameter("IVRClientCore_003_GetIDForVRInitError", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_026(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_026_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_026_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_026_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_026_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_026_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_026_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_026_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_026_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_026_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_026_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_026_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_026_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_026_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_026_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_026_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_026_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_026_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_026_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_026_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_026_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_026_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_026_Submit", 1);
    check_ptr_parameter("IVRCompositor_026_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_026_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_026_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_026_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_026_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_026_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_026_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_026_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_026_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetFrameTimings, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_026_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetFrameTimings((void *)1, 2);
    check_ptr_parameter("IVRCompositor_026_GetFrameTimings", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_GetFrameTimings", (void *)1);
    check_uint32_parameter("IVRCompositor_026_GetFrameTimings", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_026_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_026_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCumulativeStats, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetCumulativeStats((void *)1, 2);
    check_ptr_parameter("IVRCompositor_026_GetCumulativeStats", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_GetCumulativeStats", (void *)1);
    check_uint32_parameter("IVRCompositor_026_GetCumulativeStats", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_026_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_026_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_026_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_026_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_026_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_026_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_026_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_026_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_026_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCurrentFadeColor, 2, FALSE, FALSE);
    HmdColor_t *(__stdcall *capi_IVRCompositor_026_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetCurrentFadeColor(data_ptr_value, 1);
    check_ptr_parameter("IVRCompositor_026_GetCurrentFadeColor", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_GetCurrentFadeColor", data_ptr_value);
    check_bool_parameter("IVRCompositor_026_GetCurrentFadeColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_026_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_026_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_026_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_026_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCurrentGridAlpha, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_026_GetCurrentGridAlpha)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetCurrentGridAlpha();
    check_ptr_parameter("IVRCompositor_026_GetCurrentGridAlpha", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_026_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_026_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_026_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_026_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_026_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_026_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_026_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_CompositorQuit();
    check_ptr_parameter("IVRCompositor_026_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_026_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_IsFullscreen();
    check_ptr_parameter("IVRCompositor_026_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_026_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_026_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_026_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_026_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_026_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_CanRenderScene();
    check_ptr_parameter("IVRCompositor_026_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_026_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_026_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_026_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_026_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_026_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_026_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_026_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_026_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_026_ForceInterleavedReprojectionOn", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_026_ForceReconnectProcess, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_ForceReconnectProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_ForceReconnectProcess();
    check_ptr_parameter("IVRCompositor_026_ForceReconnectProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_SuspendRendering, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_SuspendRendering)(bool bSuspend) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_SuspendRendering(1);
    check_ptr_parameter("IVRCompositor_026_SuspendRendering", this_ptr_value);
    check_bool_parameter("IVRCompositor_026_SuspendRendering", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetMirrorTextureD3D11, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureD3D11", this_ptr_value);
    check_uint32_parameter("IVRCompositor_026_GetMirrorTextureD3D11", 1);
    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureD3D11", (void *)2);
    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureD3D11", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_026_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_ReleaseMirrorTextureD3D11((void *)1);
    check_ptr_parameter("IVRCompositor_026_ReleaseMirrorTextureD3D11", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_ReleaseMirrorTextureD3D11", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetMirrorTextureGL, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetMirrorTextureGL(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureGL", this_ptr_value);
    check_uint32_parameter("IVRCompositor_026_GetMirrorTextureGL", 1);
    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureGL", (void *)2);
    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureGL", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_026_ReleaseSharedGLTexture, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_026_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_ReleaseSharedGLTexture(1, (void *)2);
    check_ptr_parameter("IVRCompositor_026_ReleaseSharedGLTexture", this_ptr_value);
    check_uint32_parameter("IVRCompositor_026_ReleaseSharedGLTexture", 1);
    check_ptr_parameter("IVRCompositor_026_ReleaseSharedGLTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_026_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_LockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_026_LockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_LockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_026_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_UnlockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_026_UnlockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_UnlockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_026_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetVulkanInstanceExtensionsRequired((void *)1, 2);
    check_ptr_parameter("IVRCompositor_026_GetVulkanInstanceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_GetVulkanInstanceExtensionsRequired", (void *)1);
    check_uint32_parameter("IVRCompositor_026_GetVulkanInstanceExtensionsRequired", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_026_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRCompositor_026_GetVulkanDeviceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_GetVulkanDeviceExtensionsRequired", (void *)1);
    check_ptr_parameter("IVRCompositor_026_GetVulkanDeviceExtensionsRequired", (void *)2);
    check_uint32_parameter("IVRCompositor_026_GetVulkanDeviceExtensionsRequired", 3);

    init_thunk(t, this_ptr_value, IVRCompositor_026_SetExplicitTimingMode, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_SetExplicitTimingMode)(EVRCompositorTimingMode eTimingMode) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_SetExplicitTimingMode(1);
    check_ptr_parameter("IVRCompositor_026_SetExplicitTimingMode", this_ptr_value);
    check_uint32_parameter("IVRCompositor_026_SetExplicitTimingMode", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_026_SubmitExplicitTimingData, 0, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_026_SubmitExplicitTimingData)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_SubmitExplicitTimingData();
    check_ptr_parameter("IVRCompositor_026_SubmitExplicitTimingData", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_IsMotionSmoothingEnabled, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_026_IsMotionSmoothingEnabled)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_IsMotionSmoothingEnabled();
    check_ptr_parameter("IVRCompositor_026_IsMotionSmoothingEnabled", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_IsMotionSmoothingSupported, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_026_IsMotionSmoothingSupported)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_IsMotionSmoothingSupported();
    check_ptr_parameter("IVRCompositor_026_IsMotionSmoothingSupported", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_IsCurrentSceneFocusAppLoading, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_026_IsCurrentSceneFocusAppLoading)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_IsCurrentSceneFocusAppLoading();
    check_ptr_parameter("IVRCompositor_026_IsCurrentSceneFocusAppLoading", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_SetStageOverride_Async, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_026_SetStageOverride_Async)(const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_SetStageOverride_Async((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_026_SetStageOverride_Async", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_SetStageOverride_Async", (void *)1);
    check_ptr_parameter("IVRCompositor_026_SetStageOverride_Async", (void *)2);
    check_ptr_parameter("IVRCompositor_026_SetStageOverride_Async", (void *)3);
    check_uint32_parameter("IVRCompositor_026_SetStageOverride_Async", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_026_ClearStageOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_026_ClearStageOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_ClearStageOverride();
    check_ptr_parameter("IVRCompositor_026_ClearStageOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCompositorBenchmarkResults, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_026_GetCompositorBenchmarkResults)(Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetCompositorBenchmarkResults((void *)1, 2);
    check_ptr_parameter("IVRCompositor_026_GetCompositorBenchmarkResults", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_GetCompositorBenchmarkResults", (void *)1);
    check_uint32_parameter("IVRCompositor_026_GetCompositorBenchmarkResults", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetLastPosePredictionIDs, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetLastPosePredictionIDs)(uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetLastPosePredictionIDs((void *)1, (void *)2);
    check_ptr_parameter("IVRCompositor_026_GetLastPosePredictionIDs", this_ptr_value);
    check_ptr_parameter("IVRCompositor_026_GetLastPosePredictionIDs", (void *)1);
    check_ptr_parameter("IVRCompositor_026_GetLastPosePredictionIDs", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_026_GetPosesForFrame, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetPosesForFrame)(uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_026_GetPosesForFrame(1, (void *)2, 3);
    check_ptr_parameter("IVRCompositor_026_GetPosesForFrame", this_ptr_value);
    check_uint32_parameter("IVRCompositor_026_GetPosesForFrame", 1);
    check_ptr_parameter("IVRCompositor_026_GetPosesForFrame", (void *)2);
    check_uint32_parameter("IVRCompositor_026_GetPosesForFrame", 3);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_024(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_024_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_024_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_024_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_024_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_024_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_024_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_024_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_024_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_024_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_024_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_024_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_024_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_024_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_024_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_024_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_024_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_024_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_024_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayName, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayName(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_SetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayName", 1);
    check_ptr_parameter("IVROverlay_024_SetOverlayName", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_024_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_024_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_024_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_024_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_024_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_024_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_024_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_024_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_024_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_024_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_024_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_024_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_024_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_024_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_024_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_024_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_024_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayFlags, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayFlags(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayFlags", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayFlags", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayFlags", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_024_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_024_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_024_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_024_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_024_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_024_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_024_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_024_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTexelAspect, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayTexelAspect(1, 2.0f);
    check_ptr_parameter("IVROverlay_024_SetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayTexelAspect", 1);
    check_float_parameter("IVROverlay_024_SetOverlayTexelAspect", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTexelAspect, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayTexelAspect(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayTexelAspect", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayTexelAspect", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlaySortOrder(1, 2);
    check_ptr_parameter("IVROverlay_024_SetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlaySortOrder", 1);
    check_uint32_parameter("IVROverlay_024_SetOverlaySortOrder", 2);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlaySortOrder(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlaySortOrder", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlaySortOrder", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_024_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_024_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayCurvature, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float fCurvature) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayCurvature(1, 2.0f);
    check_ptr_parameter("IVROverlay_024_SetOverlayCurvature", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayCurvature", 1);
    check_float_parameter("IVROverlay_024_SetOverlayCurvature", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayCurvature, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float * pfCurvature) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayCurvature(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayCurvature", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayCurvature", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayCurvature", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_024_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_024_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_024_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_024_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_024_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_024_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayTransformOverlayRelative", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformOverlayRelative", (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_024_SetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayTransformOverlayRelative", 1);
    check_uint64_parameter("IVROverlay_024_SetOverlayTransformOverlayRelative", 2);
    check_ptr_parameter("IVROverlay_024_SetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformCursor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformCursor)(VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayTransformCursor(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_SetOverlayTransformCursor", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayTransformCursor", 1);
    check_ptr_parameter("IVROverlay_024_SetOverlayTransformCursor", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformCursor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformCursor)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayTransformCursor(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformCursor", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayTransformCursor", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayTransformCursor", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_024_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_024_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_HideOverlay(1);
    check_ptr_parameter("IVROverlay_024_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_024_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_024_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_024_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_024_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_024_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_024_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_024_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_024_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_024_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_024_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_024_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_024_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_024_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_024_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_024_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_024_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_024_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_024_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayIntersectionMask, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
    check_ptr_parameter("IVROverlay_024_SetOverlayIntersectionMask", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayIntersectionMask", 1);
    check_ptr_parameter("IVROverlay_024_SetOverlayIntersectionMask", (void *)2);
    check_uint32_parameter("IVROverlay_024_SetOverlayIntersectionMask", 3);
    check_uint32_parameter("IVROverlay_024_SetOverlayIntersectionMask", 4);

    init_thunk(t, this_ptr_value, IVROverlay_024_TriggerLaserMouseHapticVibration, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_TriggerLaserMouseHapticVibration)(VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_TriggerLaserMouseHapticVibration(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", 1);
    check_float_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", 2.0f);
    check_float_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", 3.0f);
    check_float_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayCursor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayCursor)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayCursor(1, 2);
    check_ptr_parameter("IVROverlay_024_SetOverlayCursor", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayCursor", 1);
    check_uint64_parameter("IVROverlay_024_SetOverlayCursor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayCursorPositionOverride, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayCursorPositionOverride(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_SetOverlayCursorPositionOverride", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayCursorPositionOverride", 1);
    check_ptr_parameter("IVROverlay_024_SetOverlayCursorPositionOverride", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_ClearOverlayCursorPositionOverride, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_ClearOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_ClearOverlayCursorPositionOverride(1);
    check_ptr_parameter("IVROverlay_024_ClearOverlayCursorPositionOverride", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_ClearOverlayCursorPositionOverride", 1);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_024_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_024_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_024_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_024_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_024_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_024_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_024_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_024_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTexture, 9, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)8);
    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)9);

    init_thunk(t, this_ptr_value, IVROverlay_024_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_024_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTextureSize, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetOverlayTextureSize(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_024_GetOverlayTextureSize", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetOverlayTextureSize", 1);
    check_ptr_parameter("IVROverlay_024_GetOverlayTextureSize", (void *)2);
    check_ptr_parameter("IVROverlay_024_GetOverlayTextureSize", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_024_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_024_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_024_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_024_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_024_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_024_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_024_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_024_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_024_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_024_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_024_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_024_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_024_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_024_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_024_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_024_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_ShowKeyboard(1, 2, 3, (void *)4, 5, (void *)6, 7);
    check_ptr_parameter("IVROverlay_024_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_024_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_024_ShowKeyboard", 2);
    check_uint32_parameter("IVROverlay_024_ShowKeyboard", 3);
    check_ptr_parameter("IVROverlay_024_ShowKeyboard", (void *)4);
    check_uint32_parameter("IVROverlay_024_ShowKeyboard", 5);
    check_ptr_parameter("IVROverlay_024_ShowKeyboard", (void *)6);
    check_uint64_parameter("IVROverlay_024_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_024_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_024_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_ShowKeyboardForOverlay(1, 2, 3, 4, (void *)5, 6, (void *)7, 8);
    check_ptr_parameter("IVROverlay_024_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_024_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_024_ShowKeyboardForOverlay", 3);
    check_uint32_parameter("IVROverlay_024_ShowKeyboardForOverlay", 4);
    check_ptr_parameter("IVROverlay_024_ShowKeyboardForOverlay", (void *)5);
    check_uint32_parameter("IVROverlay_024_ShowKeyboardForOverlay", 6);
    check_ptr_parameter("IVROverlay_024_ShowKeyboardForOverlay", (void *)7);
    check_uint64_parameter("IVROverlay_024_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_024_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_024_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_024_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_024_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_024_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_024_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_024_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_HideKeyboard();
    check_ptr_parameter("IVROverlay_024_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_024_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_024_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_024_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_024_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_024_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_024_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_024_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_024_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_024_SetKeyboardPositionForOverlay", DEFAULT_RECT);

    init_thunk(t, this_ptr_value, IVROverlay_024_ShowMessageOverlay, 6, FALSE, FALSE);
    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_024_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)4);
    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)5);
    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)6);

    init_thunk(t, this_ptr_value, IVROverlay_024_CloseMessageOverlay, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_024_CloseMessageOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_024_CloseMessageOverlay();
    check_ptr_parameter("IVROverlay_024_CloseMessageOverlay", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_021(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_021_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_021_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_021_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetProjectionMatrix, 4, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_021_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_021_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_021_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_021_GetProjectionMatrix", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_021_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_021_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_021_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_021_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_021_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_021_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_021_ComputeDistortion, 4, TRUE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
    check_ptr_parameter("IVRSystem_021_ComputeDistortion", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_021_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_021_ComputeDistortion", 3.0f);
    check_ptr_parameter("IVRSystem_021_ComputeDistortion", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_021_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_021_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_021_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_021_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_021_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_021_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetDXGIOutputInfo, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_021_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetDXGIOutputInfo((void *)1);
    check_ptr_parameter("IVRSystem_021_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetDXGIOutputInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetOutputDevice, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_021_GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetOutputDevice((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_021_GetOutputDevice", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetOutputDevice", (void *)1);
    check_uint32_parameter("IVRSystem_021_GetOutputDevice", 2);
    check_ptr_parameter("IVRSystem_021_GetOutputDevice", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_021_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_021_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_021_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_021_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_021_SetDisplayVisibility", 1);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_021_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_021_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_021_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_021_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_021_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_021_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_021_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_021_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_021_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_021_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_021_ApplyTransform, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_021_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_ApplyTransform((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_021_ApplyTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_ApplyTransform", (void *)1);
    check_ptr_parameter("IVRSystem_021_ApplyTransform", (void *)2);
    check_ptr_parameter("IVRSystem_021_ApplyTransform", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_021_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetTrackedDeviceIndexForControllerRole(1);
    check_ptr_parameter("IVRSystem_021_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetTrackedDeviceIndexForControllerRole", 1);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
    ETrackedControllerRole (__stdcall *capi_IVRSystem_021_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetControllerRoleForTrackedDeviceIndex(1);
    check_ptr_parameter("IVRSystem_021_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetControllerRoleForTrackedDeviceIndex", 1);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetTrackedDeviceClass, 1, FALSE, FALSE);
    ETrackedDeviceClass (__stdcall *capi_IVRSystem_021_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_021_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_021_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_021_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_021_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_021_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_021_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_021_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_021_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_021_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_021_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_021_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_021_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_021_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_021_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_021_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_021_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_021_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_021_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_021_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_021_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_021_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_021_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetArrayTrackedDeviceProperty, 6, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_021_GetArrayTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetArrayTrackedDeviceProperty(1, 2, 3, (void *)4, 5, (void *)6);
    check_ptr_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", 2);
    check_uint32_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", 3);
    check_ptr_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", (void *)4);
    check_uint32_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", 5);
    check_ptr_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", (void *)6);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_021_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_021_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_021_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_021_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_021_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_021_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_021_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_021_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_021_PollNextEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_PollNextEvent((void *)1, 2);
    check_ptr_parameter("IVRSystem_021_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_PollNextEvent", (void *)1);
    check_uint32_parameter("IVRSystem_021_PollNextEvent", 2);

    init_thunk(t, this_ptr_value, IVRSystem_021_PollNextEventWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSystem_021_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_021_PollNextEventWithPose", (void *)2);
    check_uint32_parameter("IVRSystem_021_PollNextEventWithPose", 3);
    check_ptr_parameter("IVRSystem_021_PollNextEventWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_021_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_021_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetHiddenAreaMesh, 3, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_021_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetHiddenAreaMesh(data_ptr_value, 1, 2);
    check_ptr_parameter("IVRSystem_021_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetHiddenAreaMesh", 1);
    check_uint32_parameter("IVRSystem_021_GetHiddenAreaMesh", 2);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetControllerState, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetControllerState(1, (void *)2, 3);
    check_ptr_parameter("IVRSystem_021_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_021_GetControllerState", (void *)2);
    check_uint32_parameter("IVRSystem_021_GetControllerState", 3);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetControllerStateWithPose, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_021_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_021_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_021_GetControllerStateWithPose", (void *)3);
    check_uint32_parameter("IVRSystem_021_GetControllerStateWithPose", 4);
    check_ptr_parameter("IVRSystem_021_GetControllerStateWithPose", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_021_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_021_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_021_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_021_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_021_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_021_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_021_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_021_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_021_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_021_IsInputAvailable, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_IsInputAvailable)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_IsInputAvailable();
    check_ptr_parameter("IVRSystem_021_IsInputAvailable", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_021_IsSteamVRDrawingControllers, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_IsSteamVRDrawingControllers)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_IsSteamVRDrawingControllers();
    check_ptr_parameter("IVRSystem_021_IsSteamVRDrawingControllers", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_021_ShouldApplicationPause, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_ShouldApplicationPause)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_ShouldApplicationPause();
    check_ptr_parameter("IVRSystem_021_ShouldApplicationPause", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_021_ShouldApplicationReduceRenderingWork, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_021_ShouldApplicationReduceRenderingWork)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_ShouldApplicationReduceRenderingWork();
    check_ptr_parameter("IVRSystem_021_ShouldApplicationReduceRenderingWork", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_021_PerformFirmwareUpdate, 1, FALSE, FALSE);
    EVRFirmwareError (__stdcall *capi_IVRSystem_021_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_021_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_021_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_021_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_021_AcknowledgeQuit_Exiting)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_AcknowledgeQuit_Exiting();
    check_ptr_parameter("IVRSystem_021_AcknowledgeQuit_Exiting", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetAppContainerFilePaths, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_021_GetAppContainerFilePaths)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetAppContainerFilePaths((void *)1, 2);
    check_ptr_parameter("IVRSystem_021_GetAppContainerFilePaths", this_ptr_value);
    check_ptr_parameter("IVRSystem_021_GetAppContainerFilePaths", (void *)1);
    check_uint32_parameter("IVRSystem_021_GetAppContainerFilePaths", 2);

    init_thunk(t, this_ptr_value, IVRSystem_021_GetRuntimeVersion, 0, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_021_GetRuntimeVersion)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_021_GetRuntimeVersion();
    check_ptr_parameter("IVRSystem_021_GetRuntimeVersion", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRChaperone_003(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRChaperone_003_GetCalibrationState, 0, FALSE, FALSE);
    ChaperoneCalibrationState (__stdcall *capi_IVRChaperone_003_GetCalibrationState)() = (void *)t;

    clear_parameters();
    capi_IVRChaperone_003_GetCalibrationState();
    check_ptr_parameter("IVRChaperone_003_GetCalibrationState", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperone_003_GetPlayAreaSize, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperone_003_GetPlayAreaSize)(float * pSizeX, float * pSizeZ) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_003_GetPlayAreaSize((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperone_003_GetPlayAreaSize", this_ptr_value);
    check_ptr_parameter("IVRChaperone_003_GetPlayAreaSize", (void *)1);
    check_ptr_parameter("IVRChaperone_003_GetPlayAreaSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperone_003_GetPlayAreaRect, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperone_003_GetPlayAreaRect)(HmdQuad_t * rect) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_003_GetPlayAreaRect((void *)1);
    check_ptr_parameter("IVRChaperone_003_GetPlayAreaRect", this_ptr_value);
    check_ptr_parameter("IVRChaperone_003_GetPlayAreaRect", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperone_003_ReloadInfo, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperone_003_ReloadInfo)() = (void *)t;

    clear_parameters();
    capi_IVRChaperone_003_ReloadInfo();
    check_ptr_parameter("IVRChaperone_003_ReloadInfo", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperone_003_SetSceneColor, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperone_003_SetSceneColor)(HmdColor_t color) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_003_SetSceneColor(DEFAULT_COLOR);
    check_ptr_parameter("IVRChaperone_003_SetSceneColor", this_ptr_value);
    check_HmdColor_parameter("IVRChaperone_003_SetSceneColor", DEFAULT_COLOR);

    init_thunk(t, this_ptr_value, IVRChaperone_003_GetBoundsColor, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRChaperone_003_GetBoundsColor)(HmdColor_t * pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t * pOutputCameraColor) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_003_GetBoundsColor((void *)1, 2, 3.0f, (void *)4);
    check_ptr_parameter("IVRChaperone_003_GetBoundsColor", this_ptr_value);
    check_ptr_parameter("IVRChaperone_003_GetBoundsColor", (void *)1);
    check_uint32_parameter("IVRChaperone_003_GetBoundsColor", 2);
    check_float_parameter("IVRChaperone_003_GetBoundsColor", 3.0f);
    check_ptr_parameter("IVRChaperone_003_GetBoundsColor", (void *)4);

    init_thunk(t, this_ptr_value, IVRChaperone_003_AreBoundsVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperone_003_AreBoundsVisible)() = (void *)t;

    clear_parameters();
    capi_IVRChaperone_003_AreBoundsVisible();
    check_ptr_parameter("IVRChaperone_003_AreBoundsVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperone_003_ForceBoundsVisible, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperone_003_ForceBoundsVisible)(bool bForce) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_003_ForceBoundsVisible(1);
    check_ptr_parameter("IVRChaperone_003_ForceBoundsVisible", this_ptr_value);
    check_bool_parameter("IVRChaperone_003_ForceBoundsVisible", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRControlPanel_006(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc1, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRControlPanel_006_undoc1)() = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc1();
    check_ptr_parameter("IVRControlPanel_006_undoc1", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc2, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRControlPanel_006_undoc2)(uint32_t a, char * b, uint32_t c) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc2(1, (void *)2, 3);
    check_ptr_parameter("IVRControlPanel_006_undoc2", this_ptr_value);
    check_uint32_parameter("IVRControlPanel_006_undoc2", 1);
    check_ptr_parameter("IVRControlPanel_006_undoc2", (void *)2);
    check_uint32_parameter("IVRControlPanel_006_undoc2", 3);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc3, 1, FALSE, FALSE);
    EVRInitError (__stdcall *capi_IVRControlPanel_006_undoc3)(const char * a) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc3((void *)1);
    check_ptr_parameter("IVRControlPanel_006_undoc3", this_ptr_value);
    check_ptr_parameter("IVRControlPanel_006_undoc3", (void *)1);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc4, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRControlPanel_006_undoc4)(const char * a) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc4((void *)1);
    check_ptr_parameter("IVRControlPanel_006_undoc4", this_ptr_value);
    check_ptr_parameter("IVRControlPanel_006_undoc4", (void *)1);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc5, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRControlPanel_006_undoc5)(const char * a, uint32_t b, char * c, uint32_t d) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc5((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRControlPanel_006_undoc5", this_ptr_value);
    check_ptr_parameter("IVRControlPanel_006_undoc5", (void *)1);
    check_uint32_parameter("IVRControlPanel_006_undoc5", 2);
    check_ptr_parameter("IVRControlPanel_006_undoc5", (void *)3);
    check_uint32_parameter("IVRControlPanel_006_undoc5", 4);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc6, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRControlPanel_006_undoc6)(const char * a, const char * b, char * c, uint32_t d) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc6((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRControlPanel_006_undoc6", this_ptr_value);
    check_ptr_parameter("IVRControlPanel_006_undoc6", (void *)1);
    check_ptr_parameter("IVRControlPanel_006_undoc6", (void *)2);
    check_ptr_parameter("IVRControlPanel_006_undoc6", (void *)3);
    check_uint32_parameter("IVRControlPanel_006_undoc6", 4);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc7, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRControlPanel_006_undoc7)(const char * a, const char * b, char * c, uint32_t d) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc7((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRControlPanel_006_undoc7", this_ptr_value);
    check_ptr_parameter("IVRControlPanel_006_undoc7", (void *)1);
    check_ptr_parameter("IVRControlPanel_006_undoc7", (void *)2);
    check_ptr_parameter("IVRControlPanel_006_undoc7", (void *)3);
    check_uint32_parameter("IVRControlPanel_006_undoc7", 4);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc8, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRControlPanel_006_undoc8)(uint32_t a) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc8(1);
    check_ptr_parameter("IVRControlPanel_006_undoc8", this_ptr_value);
    check_uint32_parameter("IVRControlPanel_006_undoc8", 1);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc9, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRControlPanel_006_undoc9)() = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc9();
    check_ptr_parameter("IVRControlPanel_006_undoc9", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc10, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRControlPanel_006_undoc10)() = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc10();
    check_ptr_parameter("IVRControlPanel_006_undoc10", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc11, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRControlPanel_006_undoc11)(uint32_t a) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc11(1);
    check_ptr_parameter("IVRControlPanel_006_undoc11", this_ptr_value);
    check_uint32_parameter("IVRControlPanel_006_undoc11", 1);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc12, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRControlPanel_006_undoc12)() = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc12();
    check_ptr_parameter("IVRControlPanel_006_undoc12", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc13, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRControlPanel_006_undoc13)(TrackedDeviceIndex_t a) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc13(1);
    check_ptr_parameter("IVRControlPanel_006_undoc13", this_ptr_value);
    check_uint32_parameter("IVRControlPanel_006_undoc13", 1);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc14, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRControlPanel_006_undoc14)(EVRState a) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc14(1);
    check_ptr_parameter("IVRControlPanel_006_undoc14", this_ptr_value);
    check_uint32_parameter("IVRControlPanel_006_undoc14", 1);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc15, 0, FALSE, FALSE);
    EVRState (__stdcall *capi_IVRControlPanel_006_undoc15)() = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc15();
    check_ptr_parameter("IVRControlPanel_006_undoc15", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc16, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRControlPanel_006_undoc16)(bool a) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc16(1);
    check_ptr_parameter("IVRControlPanel_006_undoc16", this_ptr_value);
    check_bool_parameter("IVRControlPanel_006_undoc16", 1);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc17, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRControlPanel_006_undoc17)() = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc17();
    check_ptr_parameter("IVRControlPanel_006_undoc17", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc18, 0, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRControlPanel_006_undoc18)() = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc18();
    check_ptr_parameter("IVRControlPanel_006_undoc18", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc19, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRControlPanel_006_undoc19)(bool a) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc19(1);
    check_ptr_parameter("IVRControlPanel_006_undoc19", this_ptr_value);
    check_bool_parameter("IVRControlPanel_006_undoc19", 1);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc20, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRControlPanel_006_undoc20)() = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc20();
    check_ptr_parameter("IVRControlPanel_006_undoc20", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc21, 0, FALSE, FALSE);
    EVRInitError (__stdcall *capi_IVRControlPanel_006_undoc21)() = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc21();
    check_ptr_parameter("IVRControlPanel_006_undoc21", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc22, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRControlPanel_006_undoc22)(WebConsoleHandle_t a, const char * b, uint32_t c, uint32_t d, const char * e) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc22(1, (void *)2, 3, 4, (void *)5);
    check_ptr_parameter("IVRControlPanel_006_undoc22", this_ptr_value);
    check_uint64_parameter("IVRControlPanel_006_undoc22", 1);
    check_ptr_parameter("IVRControlPanel_006_undoc22", (void *)2);
    check_uint32_parameter("IVRControlPanel_006_undoc22", 3);
    check_uint32_parameter("IVRControlPanel_006_undoc22", 4);
    check_ptr_parameter("IVRControlPanel_006_undoc22", (void *)5);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc23, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRControlPanel_006_undoc23)(const char * a) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc23((void *)1);
    check_ptr_parameter("IVRControlPanel_006_undoc23", this_ptr_value);
    check_ptr_parameter("IVRControlPanel_006_undoc23", (void *)1);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc24, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRControlPanel_006_undoc24)() = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc24();
    check_ptr_parameter("IVRControlPanel_006_undoc24", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc25, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRControlPanel_006_undoc25)(bool a) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc25(1);
    check_ptr_parameter("IVRControlPanel_006_undoc25", this_ptr_value);
    check_bool_parameter("IVRControlPanel_006_undoc25", 1);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc26, 0, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRControlPanel_006_undoc26)() = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc26();
    check_ptr_parameter("IVRControlPanel_006_undoc26", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc27, 1, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRControlPanel_006_undoc27)(const char * a) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc27((void *)1);
    check_ptr_parameter("IVRControlPanel_006_undoc27", this_ptr_value);
    check_ptr_parameter("IVRControlPanel_006_undoc27", (void *)1);

    init_thunk(t, this_ptr_value, IVRControlPanel_006_undoc28, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRControlPanel_006_undoc28)(VROverlayHandle_t a) = (void *)t;

    clear_parameters();
    capi_IVRControlPanel_006_undoc28(1);
    check_ptr_parameter("IVRControlPanel_006_undoc28", this_ptr_value);
    check_uint64_parameter("IVRControlPanel_006_undoc28", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRMailbox_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRMailbox_001_undoc1, 2, FALSE, FALSE);
    vrmb_typeb (__stdcall *capi_IVRMailbox_001_undoc1)(const char * a, vrmb_typea * b) = (void *)t;

    clear_parameters();
    capi_IVRMailbox_001_undoc1((void *)1, (void *)2);
    check_ptr_parameter("IVRMailbox_001_undoc1", this_ptr_value);
    check_ptr_parameter("IVRMailbox_001_undoc1", (void *)1);
    check_ptr_parameter("IVRMailbox_001_undoc1", (void *)2);

    init_thunk(t, this_ptr_value, IVRMailbox_001_undoc2, 1, FALSE, FALSE);
    vrmb_typeb (__stdcall *capi_IVRMailbox_001_undoc2)(vrmb_typea a) = (void *)t;

    clear_parameters();
    capi_IVRMailbox_001_undoc2(1);
    check_ptr_parameter("IVRMailbox_001_undoc2", this_ptr_value);
    check_uint64_parameter("IVRMailbox_001_undoc2", 1);

    init_thunk(t, this_ptr_value, IVRMailbox_001_undoc3, 3, FALSE, FALSE);
    vrmb_typeb (__stdcall *capi_IVRMailbox_001_undoc3)(vrmb_typea a, const char * b, const char * c) = (void *)t;

    clear_parameters();
    capi_IVRMailbox_001_undoc3(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRMailbox_001_undoc3", this_ptr_value);
    check_uint64_parameter("IVRMailbox_001_undoc3", 1);
    check_ptr_parameter("IVRMailbox_001_undoc3", (void *)2);
    check_ptr_parameter("IVRMailbox_001_undoc3", (void *)3);

    init_thunk(t, this_ptr_value, IVRMailbox_001_undoc4, 4, FALSE, FALSE);
    vrmb_typeb (__stdcall *capi_IVRMailbox_001_undoc4)(vrmb_typea a, char * b, uint32_t c, uint32_t * d) = (void *)t;

    clear_parameters();
    capi_IVRMailbox_001_undoc4(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRMailbox_001_undoc4", this_ptr_value);
    check_uint64_parameter("IVRMailbox_001_undoc4", 1);
    check_ptr_parameter("IVRMailbox_001_undoc4", (void *)2);
    check_uint32_parameter("IVRMailbox_001_undoc4", 3);
    check_ptr_parameter("IVRMailbox_001_undoc4", (void *)4);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_024(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_024_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_024_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_024_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_024_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_024_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_024_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_024_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_024_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_024_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_024_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_024_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_024_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_024_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_024_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_024_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_024_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_024_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_024_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_024_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_024_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_024_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_024_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_024_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_024_Submit", 1);
    check_ptr_parameter("IVRCompositor_024_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_024_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_024_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_024_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_024_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_024_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_024_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_024_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_024_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetFrameTimings, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_024_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetFrameTimings((void *)1, 2);
    check_ptr_parameter("IVRCompositor_024_GetFrameTimings", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_GetFrameTimings", (void *)1);
    check_uint32_parameter("IVRCompositor_024_GetFrameTimings", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_024_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_024_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetCumulativeStats, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetCumulativeStats((void *)1, 2);
    check_ptr_parameter("IVRCompositor_024_GetCumulativeStats", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_GetCumulativeStats", (void *)1);
    check_uint32_parameter("IVRCompositor_024_GetCumulativeStats", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_024_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_024_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_024_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_024_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_024_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_024_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_024_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_024_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_024_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetCurrentFadeColor, 2, FALSE, FALSE);
    HmdColor_t *(__stdcall *capi_IVRCompositor_024_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetCurrentFadeColor(data_ptr_value, 1);
    check_ptr_parameter("IVRCompositor_024_GetCurrentFadeColor", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_GetCurrentFadeColor", data_ptr_value);
    check_bool_parameter("IVRCompositor_024_GetCurrentFadeColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_024_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_024_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_024_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_024_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetCurrentGridAlpha, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_024_GetCurrentGridAlpha)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetCurrentGridAlpha();
    check_ptr_parameter("IVRCompositor_024_GetCurrentGridAlpha", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_024_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_024_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_024_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_024_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_024_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_024_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_024_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_CompositorQuit();
    check_ptr_parameter("IVRCompositor_024_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_024_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_IsFullscreen();
    check_ptr_parameter("IVRCompositor_024_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_024_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_024_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_024_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_024_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_024_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_CanRenderScene();
    check_ptr_parameter("IVRCompositor_024_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_024_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_024_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_024_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_024_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_024_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_024_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_024_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_024_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_024_ForceInterleavedReprojectionOn", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_024_ForceReconnectProcess, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_ForceReconnectProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_ForceReconnectProcess();
    check_ptr_parameter("IVRCompositor_024_ForceReconnectProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_SuspendRendering, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_SuspendRendering)(bool bSuspend) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_SuspendRendering(1);
    check_ptr_parameter("IVRCompositor_024_SuspendRendering", this_ptr_value);
    check_bool_parameter("IVRCompositor_024_SuspendRendering", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetMirrorTextureD3D11, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_024_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_024_GetMirrorTextureD3D11", this_ptr_value);
    check_uint32_parameter("IVRCompositor_024_GetMirrorTextureD3D11", 1);
    check_ptr_parameter("IVRCompositor_024_GetMirrorTextureD3D11", (void *)2);
    check_ptr_parameter("IVRCompositor_024_GetMirrorTextureD3D11", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_024_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_ReleaseMirrorTextureD3D11((void *)1);
    check_ptr_parameter("IVRCompositor_024_ReleaseMirrorTextureD3D11", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_ReleaseMirrorTextureD3D11", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetMirrorTextureGL, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_024_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetMirrorTextureGL(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_024_GetMirrorTextureGL", this_ptr_value);
    check_uint32_parameter("IVRCompositor_024_GetMirrorTextureGL", 1);
    check_ptr_parameter("IVRCompositor_024_GetMirrorTextureGL", (void *)2);
    check_ptr_parameter("IVRCompositor_024_GetMirrorTextureGL", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_024_ReleaseSharedGLTexture, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_024_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_ReleaseSharedGLTexture(1, (void *)2);
    check_ptr_parameter("IVRCompositor_024_ReleaseSharedGLTexture", this_ptr_value);
    check_uint32_parameter("IVRCompositor_024_ReleaseSharedGLTexture", 1);
    check_ptr_parameter("IVRCompositor_024_ReleaseSharedGLTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_024_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_LockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_024_LockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_LockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_024_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_UnlockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_024_UnlockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_UnlockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_024_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetVulkanInstanceExtensionsRequired((void *)1, 2);
    check_ptr_parameter("IVRCompositor_024_GetVulkanInstanceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_GetVulkanInstanceExtensionsRequired", (void *)1);
    check_uint32_parameter("IVRCompositor_024_GetVulkanInstanceExtensionsRequired", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_024_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_024_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRCompositor_024_GetVulkanDeviceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_GetVulkanDeviceExtensionsRequired", (void *)1);
    check_ptr_parameter("IVRCompositor_024_GetVulkanDeviceExtensionsRequired", (void *)2);
    check_uint32_parameter("IVRCompositor_024_GetVulkanDeviceExtensionsRequired", 3);

    init_thunk(t, this_ptr_value, IVRCompositor_024_SetExplicitTimingMode, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_SetExplicitTimingMode)(EVRCompositorTimingMode eTimingMode) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_SetExplicitTimingMode(1);
    check_ptr_parameter("IVRCompositor_024_SetExplicitTimingMode", this_ptr_value);
    check_uint32_parameter("IVRCompositor_024_SetExplicitTimingMode", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_024_SubmitExplicitTimingData, 0, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_024_SubmitExplicitTimingData)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_SubmitExplicitTimingData();
    check_ptr_parameter("IVRCompositor_024_SubmitExplicitTimingData", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_IsMotionSmoothingEnabled, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_024_IsMotionSmoothingEnabled)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_IsMotionSmoothingEnabled();
    check_ptr_parameter("IVRCompositor_024_IsMotionSmoothingEnabled", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_IsMotionSmoothingSupported, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_024_IsMotionSmoothingSupported)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_IsMotionSmoothingSupported();
    check_ptr_parameter("IVRCompositor_024_IsMotionSmoothingSupported", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_IsCurrentSceneFocusAppLoading, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_024_IsCurrentSceneFocusAppLoading)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_IsCurrentSceneFocusAppLoading();
    check_ptr_parameter("IVRCompositor_024_IsCurrentSceneFocusAppLoading", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_024_SetStageOverride_Async, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_024_SetStageOverride_Async)(const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_SetStageOverride_Async((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_024_SetStageOverride_Async", this_ptr_value);
    check_ptr_parameter("IVRCompositor_024_SetStageOverride_Async", (void *)1);
    check_ptr_parameter("IVRCompositor_024_SetStageOverride_Async", (void *)2);
    check_ptr_parameter("IVRCompositor_024_SetStageOverride_Async", (void *)3);
    check_uint32_parameter("IVRCompositor_024_SetStageOverride_Async", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_024_ClearStageOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_024_ClearStageOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_024_ClearStageOverride();
    check_ptr_parameter("IVRCompositor_024_ClearStageOverride", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_022(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_022_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_022_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_022_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_022_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_022_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_022_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_022_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_022_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_022_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_022_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_022_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_022_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_022_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_022_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_022_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_022_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_022_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_022_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayName, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayName(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_SetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayName", 1);
    check_ptr_parameter("IVROverlay_022_SetOverlayName", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_022_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_022_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_022_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_022_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_022_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_022_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_022_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_022_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_022_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_022_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_022_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_022_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_022_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_022_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_022_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_022_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_022_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayFlags, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayFlags(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayFlags", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayFlags", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayFlags", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_022_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_022_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_022_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_022_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_022_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_022_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_022_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_022_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayTexelAspect, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayTexelAspect(1, 2.0f);
    check_ptr_parameter("IVROverlay_022_SetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayTexelAspect", 1);
    check_float_parameter("IVROverlay_022_SetOverlayTexelAspect", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayTexelAspect, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayTexelAspect(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayTexelAspect", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayTexelAspect", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlaySortOrder(1, 2);
    check_ptr_parameter("IVROverlay_022_SetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlaySortOrder", 1);
    check_uint32_parameter("IVROverlay_022_SetOverlaySortOrder", 2);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlaySortOrder(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlaySortOrder", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlaySortOrder", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_022_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_022_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayCurvature, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float fCurvature) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayCurvature(1, 2.0f);
    check_ptr_parameter("IVROverlay_022_SetOverlayCurvature", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayCurvature", 1);
    check_float_parameter("IVROverlay_022_SetOverlayCurvature", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayCurvature, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float * pfCurvature) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayCurvature(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayCurvature", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayCurvature", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayCurvature", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_022_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_022_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_022_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayRenderModel, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_022_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_022_GetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayRenderModel", (void *)2);
    check_uint32_parameter("IVROverlay_022_GetOverlayRenderModel", 3);
    check_ptr_parameter("IVROverlay_022_GetOverlayRenderModel", (void *)4);
    check_ptr_parameter("IVROverlay_022_GetOverlayRenderModel", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayRenderModel, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayRenderModel(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_022_SetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_022_SetOverlayRenderModel", (void *)2);
    check_ptr_parameter("IVROverlay_022_SetOverlayRenderModel", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_022_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_022_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_022_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_022_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_022_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_022_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_022_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_022_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_022_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_022_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayTransformOverlayRelative", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformOverlayRelative", (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_022_SetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayTransformOverlayRelative", 1);
    check_uint64_parameter("IVROverlay_022_SetOverlayTransformOverlayRelative", 2);
    check_ptr_parameter("IVROverlay_022_SetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayTransformCursor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayTransformCursor)(VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayTransformCursor(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_SetOverlayTransformCursor", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayTransformCursor", 1);
    check_ptr_parameter("IVROverlay_022_SetOverlayTransformCursor", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayTransformCursor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayTransformCursor)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayTransformCursor(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformCursor", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayTransformCursor", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayTransformCursor", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_022_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_022_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_HideOverlay(1);
    check_ptr_parameter("IVROverlay_022_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_022_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_022_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_022_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_022_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_022_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_022_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_022_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_022_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_022_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_022_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_022_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_022_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_022_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_022_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_022_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_022_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_022_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_022_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_022_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_022_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_022_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_022_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayDualAnalogTransform, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayDualAnalogTransform(1, 2, (void *)3, 4.0f);
    check_ptr_parameter("IVROverlay_022_SetOverlayDualAnalogTransform", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayDualAnalogTransform", 1);
    check_uint32_parameter("IVROverlay_022_SetOverlayDualAnalogTransform", 2);
    check_ptr_parameter("IVROverlay_022_SetOverlayDualAnalogTransform", (void *)3);
    check_float_parameter("IVROverlay_022_SetOverlayDualAnalogTransform", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayDualAnalogTransform, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayDualAnalogTransform(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_022_GetOverlayDualAnalogTransform", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayDualAnalogTransform", 1);
    check_uint32_parameter("IVROverlay_022_GetOverlayDualAnalogTransform", 2);
    check_ptr_parameter("IVROverlay_022_GetOverlayDualAnalogTransform", (void *)3);
    check_ptr_parameter("IVROverlay_022_GetOverlayDualAnalogTransform", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayIntersectionMask, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
    check_ptr_parameter("IVROverlay_022_SetOverlayIntersectionMask", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayIntersectionMask", 1);
    check_ptr_parameter("IVROverlay_022_SetOverlayIntersectionMask", (void *)2);
    check_uint32_parameter("IVROverlay_022_SetOverlayIntersectionMask", 3);
    check_uint32_parameter("IVROverlay_022_SetOverlayIntersectionMask", 4);

    init_thunk(t, this_ptr_value, IVROverlay_022_TriggerLaserMouseHapticVibration, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_TriggerLaserMouseHapticVibration)(VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_TriggerLaserMouseHapticVibration(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_022_TriggerLaserMouseHapticVibration", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_TriggerLaserMouseHapticVibration", 1);
    check_float_parameter("IVROverlay_022_TriggerLaserMouseHapticVibration", 2.0f);
    check_float_parameter("IVROverlay_022_TriggerLaserMouseHapticVibration", 3.0f);
    check_float_parameter("IVROverlay_022_TriggerLaserMouseHapticVibration", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayCursor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayCursor)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayCursor(1, 2);
    check_ptr_parameter("IVROverlay_022_SetOverlayCursor", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayCursor", 1);
    check_uint64_parameter("IVROverlay_022_SetOverlayCursor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayCursorPositionOverride, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayCursorPositionOverride(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_SetOverlayCursorPositionOverride", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayCursorPositionOverride", 1);
    check_ptr_parameter("IVROverlay_022_SetOverlayCursorPositionOverride", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_ClearOverlayCursorPositionOverride, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_ClearOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_ClearOverlayCursorPositionOverride(1);
    check_ptr_parameter("IVROverlay_022_ClearOverlayCursorPositionOverride", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_ClearOverlayCursorPositionOverride", 1);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_022_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_022_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_022_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_022_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_022_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_022_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_022_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_022_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayTexture, 9, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
    check_ptr_parameter("IVROverlay_022_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_022_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_022_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_022_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_022_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_022_GetOverlayTexture", (void *)8);
    check_ptr_parameter("IVROverlay_022_GetOverlayTexture", (void *)9);

    init_thunk(t, this_ptr_value, IVROverlay_022_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_022_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetOverlayTextureSize, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetOverlayTextureSize(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_022_GetOverlayTextureSize", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetOverlayTextureSize", 1);
    check_ptr_parameter("IVROverlay_022_GetOverlayTextureSize", (void *)2);
    check_ptr_parameter("IVROverlay_022_GetOverlayTextureSize", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_022_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_022_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_022_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_022_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_022_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_022_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_022_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_022_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_022_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_022_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_022_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_022_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_022_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_022_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_022_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_022_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_022_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_022_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_022_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_022_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_022_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_022_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_022_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_022_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_022_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_022_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_022_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_022_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_022_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_022_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_022_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_022_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_022_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_022_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_022_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_022_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_022_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_022_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_022_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_022_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_022_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_022_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_022_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_022_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_022_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_022_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_HideKeyboard();
    check_ptr_parameter("IVROverlay_022_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_022_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_022_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_022_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_022_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_022_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_022_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_022_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_022_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_022_SetKeyboardPositionForOverlay", DEFAULT_RECT);

    init_thunk(t, this_ptr_value, IVROverlay_022_ShowMessageOverlay, 6, FALSE, FALSE);
    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_022_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
    check_ptr_parameter("IVROverlay_022_ShowMessageOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_022_ShowMessageOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_022_ShowMessageOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_022_ShowMessageOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_022_ShowMessageOverlay", (void *)4);
    check_ptr_parameter("IVROverlay_022_ShowMessageOverlay", (void *)5);
    check_ptr_parameter("IVROverlay_022_ShowMessageOverlay", (void *)6);

    init_thunk(t, this_ptr_value, IVROverlay_022_CloseMessageOverlay, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_022_CloseMessageOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_022_CloseMessageOverlay();
    check_ptr_parameter("IVROverlay_022_CloseMessageOverlay", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRInput_007(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRInput_007_SetActionManifestPath, 1, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_SetActionManifestPath)(const char * pchActionManifestPath) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_SetActionManifestPath((void *)1);
    check_ptr_parameter("IVRInput_007_SetActionManifestPath", this_ptr_value);
    check_ptr_parameter("IVRInput_007_SetActionManifestPath", (void *)1);

    init_thunk(t, this_ptr_value, IVRInput_007_GetActionSetHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetActionSetHandle)(const char * pchActionSetName, VRActionSetHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetActionSetHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_007_GetActionSetHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_007_GetActionSetHandle", (void *)1);
    check_ptr_parameter("IVRInput_007_GetActionSetHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_007_GetActionHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetActionHandle)(const char * pchActionName, VRActionHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetActionHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_007_GetActionHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_007_GetActionHandle", (void *)1);
    check_ptr_parameter("IVRInput_007_GetActionHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_007_GetInputSourceHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetInputSourceHandle)(const char * pchInputSourcePath, VRInputValueHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetInputSourceHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_007_GetInputSourceHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_007_GetInputSourceHandle", (void *)1);
    check_ptr_parameter("IVRInput_007_GetInputSourceHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_007_UpdateActionState, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_UpdateActionState)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_UpdateActionState((void *)1, 2, 3);
    check_ptr_parameter("IVRInput_007_UpdateActionState", this_ptr_value);
    check_ptr_parameter("IVRInput_007_UpdateActionState", (void *)1);
    check_uint32_parameter("IVRInput_007_UpdateActionState", 2);
    check_uint32_parameter("IVRInput_007_UpdateActionState", 3);

    init_thunk(t, this_ptr_value, IVRInput_007_GetDigitalActionData, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetDigitalActionData)(VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetDigitalActionData(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_007_GetDigitalActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetDigitalActionData", 1);
    check_ptr_parameter("IVRInput_007_GetDigitalActionData", (void *)2);
    check_uint32_parameter("IVRInput_007_GetDigitalActionData", 3);
    check_uint64_parameter("IVRInput_007_GetDigitalActionData", 4);

    init_thunk(t, this_ptr_value, IVRInput_007_GetAnalogActionData, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetAnalogActionData)(VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetAnalogActionData(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_007_GetAnalogActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetAnalogActionData", 1);
    check_ptr_parameter("IVRInput_007_GetAnalogActionData", (void *)2);
    check_uint32_parameter("IVRInput_007_GetAnalogActionData", 3);
    check_uint64_parameter("IVRInput_007_GetAnalogActionData", 4);

    init_thunk(t, this_ptr_value, IVRInput_007_GetPoseActionDataRelativeToNow, 6, TRUE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetPoseActionDataRelativeToNow)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetPoseActionDataRelativeToNow(1, 2, 3.0f, (void *)4, 5, 6);
    check_ptr_parameter("IVRInput_007_GetPoseActionDataRelativeToNow", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetPoseActionDataRelativeToNow", 1);
    check_uint32_parameter("IVRInput_007_GetPoseActionDataRelativeToNow", 2);
    check_float_parameter("IVRInput_007_GetPoseActionDataRelativeToNow", 3.0f);
    check_ptr_parameter("IVRInput_007_GetPoseActionDataRelativeToNow", (void *)4);
    check_uint32_parameter("IVRInput_007_GetPoseActionDataRelativeToNow", 5);
    check_uint64_parameter("IVRInput_007_GetPoseActionDataRelativeToNow", 6);

    init_thunk(t, this_ptr_value, IVRInput_007_GetPoseActionDataForNextFrame, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetPoseActionDataForNextFrame)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetPoseActionDataForNextFrame(1, 2, (void *)3, 4, 5);
    check_ptr_parameter("IVRInput_007_GetPoseActionDataForNextFrame", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetPoseActionDataForNextFrame", 1);
    check_uint32_parameter("IVRInput_007_GetPoseActionDataForNextFrame", 2);
    check_ptr_parameter("IVRInput_007_GetPoseActionDataForNextFrame", (void *)3);
    check_uint32_parameter("IVRInput_007_GetPoseActionDataForNextFrame", 4);
    check_uint64_parameter("IVRInput_007_GetPoseActionDataForNextFrame", 5);

    init_thunk(t, this_ptr_value, IVRInput_007_GetSkeletalActionData, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetSkeletalActionData)(VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetSkeletalActionData(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_007_GetSkeletalActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetSkeletalActionData", 1);
    check_ptr_parameter("IVRInput_007_GetSkeletalActionData", (void *)2);
    check_uint32_parameter("IVRInput_007_GetSkeletalActionData", 3);

    init_thunk(t, this_ptr_value, IVRInput_007_GetBoneCount, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetBoneCount)(VRActionHandle_t action, uint32_t * pBoneCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetBoneCount(1, (void *)2);
    check_ptr_parameter("IVRInput_007_GetBoneCount", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetBoneCount", 1);
    check_ptr_parameter("IVRInput_007_GetBoneCount", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_007_GetBoneHierarchy, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetBoneHierarchy)(VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetBoneHierarchy(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_007_GetBoneHierarchy", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetBoneHierarchy", 1);
    check_ptr_parameter("IVRInput_007_GetBoneHierarchy", (void *)2);
    check_uint32_parameter("IVRInput_007_GetBoneHierarchy", 3);

    init_thunk(t, this_ptr_value, IVRInput_007_GetBoneName, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetBoneName)(VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetBoneName(1, 2, (void *)3, 4);
    check_ptr_parameter("IVRInput_007_GetBoneName", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetBoneName", 1);
    check_uint32_parameter("IVRInput_007_GetBoneName", 2);
    check_ptr_parameter("IVRInput_007_GetBoneName", (void *)3);
    check_uint32_parameter("IVRInput_007_GetBoneName", 4);

    init_thunk(t, this_ptr_value, IVRInput_007_GetSkeletalReferenceTransforms, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetSkeletalReferenceTransforms)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetSkeletalReferenceTransforms(1, 2, 3, (void *)4, 5);
    check_ptr_parameter("IVRInput_007_GetSkeletalReferenceTransforms", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetSkeletalReferenceTransforms", 1);
    check_uint32_parameter("IVRInput_007_GetSkeletalReferenceTransforms", 2);
    check_uint32_parameter("IVRInput_007_GetSkeletalReferenceTransforms", 3);
    check_ptr_parameter("IVRInput_007_GetSkeletalReferenceTransforms", (void *)4);
    check_uint32_parameter("IVRInput_007_GetSkeletalReferenceTransforms", 5);

    init_thunk(t, this_ptr_value, IVRInput_007_GetSkeletalTrackingLevel, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetSkeletalTrackingLevel)(VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetSkeletalTrackingLevel(1, (void *)2);
    check_ptr_parameter("IVRInput_007_GetSkeletalTrackingLevel", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetSkeletalTrackingLevel", 1);
    check_ptr_parameter("IVRInput_007_GetSkeletalTrackingLevel", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_007_GetSkeletalBoneData, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetSkeletalBoneData)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetSkeletalBoneData(1, 2, 3, (void *)4, 5);
    check_ptr_parameter("IVRInput_007_GetSkeletalBoneData", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetSkeletalBoneData", 1);
    check_uint32_parameter("IVRInput_007_GetSkeletalBoneData", 2);
    check_uint32_parameter("IVRInput_007_GetSkeletalBoneData", 3);
    check_ptr_parameter("IVRInput_007_GetSkeletalBoneData", (void *)4);
    check_uint32_parameter("IVRInput_007_GetSkeletalBoneData", 5);

    init_thunk(t, this_ptr_value, IVRInput_007_GetSkeletalSummaryData, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetSkeletalSummaryData)(VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetSkeletalSummaryData(1, 2, (void *)3);
    check_ptr_parameter("IVRInput_007_GetSkeletalSummaryData", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetSkeletalSummaryData", 1);
    check_uint32_parameter("IVRInput_007_GetSkeletalSummaryData", 2);
    check_ptr_parameter("IVRInput_007_GetSkeletalSummaryData", (void *)3);

    init_thunk(t, this_ptr_value, IVRInput_007_GetSkeletalBoneDataCompressed, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetSkeletalBoneDataCompressed)(VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetSkeletalBoneDataCompressed(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRInput_007_GetSkeletalBoneDataCompressed", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetSkeletalBoneDataCompressed", 1);
    check_uint32_parameter("IVRInput_007_GetSkeletalBoneDataCompressed", 2);
    check_ptr_parameter("IVRInput_007_GetSkeletalBoneDataCompressed", (void *)3);
    check_uint32_parameter("IVRInput_007_GetSkeletalBoneDataCompressed", 4);
    check_ptr_parameter("IVRInput_007_GetSkeletalBoneDataCompressed", (void *)5);

    init_thunk(t, this_ptr_value, IVRInput_007_DecompressSkeletalBoneData, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_DecompressSkeletalBoneData)(const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_DecompressSkeletalBoneData((void *)1, 2, 3, (void *)4, 5);
    check_ptr_parameter("IVRInput_007_DecompressSkeletalBoneData", this_ptr_value);
    check_ptr_parameter("IVRInput_007_DecompressSkeletalBoneData", (void *)1);
    check_uint32_parameter("IVRInput_007_DecompressSkeletalBoneData", 2);
    check_uint32_parameter("IVRInput_007_DecompressSkeletalBoneData", 3);
    check_ptr_parameter("IVRInput_007_DecompressSkeletalBoneData", (void *)4);
    check_uint32_parameter("IVRInput_007_DecompressSkeletalBoneData", 5);

    init_thunk(t, this_ptr_value, IVRInput_007_TriggerHapticVibrationAction, 6, TRUE, TRUE);
    EVRInputError (__stdcall *capi_IVRInput_007_TriggerHapticVibrationAction)(VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_TriggerHapticVibrationAction(1, 2.0f, 3.0f, 4.0f, 5.0f, 6);
    check_ptr_parameter("IVRInput_007_TriggerHapticVibrationAction", this_ptr_value);
    check_uint64_parameter("IVRInput_007_TriggerHapticVibrationAction", 1);
    check_float_parameter("IVRInput_007_TriggerHapticVibrationAction", 2.0f);
    check_float_parameter("IVRInput_007_TriggerHapticVibrationAction", 3.0f);
    check_float_parameter("IVRInput_007_TriggerHapticVibrationAction", 4.0f);
    check_float_parameter("IVRInput_007_TriggerHapticVibrationAction", 5.0f);
    check_uint64_parameter("IVRInput_007_TriggerHapticVibrationAction", 6);

    init_thunk(t, this_ptr_value, IVRInput_007_GetActionOrigins, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetActionOrigins(1, 2, (void *)3, 4);
    check_ptr_parameter("IVRInput_007_GetActionOrigins", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetActionOrigins", 1);
    check_uint64_parameter("IVRInput_007_GetActionOrigins", 2);
    check_ptr_parameter("IVRInput_007_GetActionOrigins", (void *)3);
    check_uint32_parameter("IVRInput_007_GetActionOrigins", 4);

    init_thunk(t, this_ptr_value, IVRInput_007_GetOriginLocalizedName, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetOriginLocalizedName)(VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetOriginLocalizedName(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_007_GetOriginLocalizedName", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetOriginLocalizedName", 1);
    check_ptr_parameter("IVRInput_007_GetOriginLocalizedName", (void *)2);
    check_uint32_parameter("IVRInput_007_GetOriginLocalizedName", 3);
    check_uint32_parameter("IVRInput_007_GetOriginLocalizedName", 4);

    init_thunk(t, this_ptr_value, IVRInput_007_GetOriginTrackedDeviceInfo, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetOriginTrackedDeviceInfo)(VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetOriginTrackedDeviceInfo(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_007_GetOriginTrackedDeviceInfo", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetOriginTrackedDeviceInfo", 1);
    check_ptr_parameter("IVRInput_007_GetOriginTrackedDeviceInfo", (void *)2);
    check_uint32_parameter("IVRInput_007_GetOriginTrackedDeviceInfo", 3);

    init_thunk(t, this_ptr_value, IVRInput_007_GetActionBindingInfo, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_GetActionBindingInfo)(VRActionHandle_t action, InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t * punReturnedBindingInfoCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_GetActionBindingInfo(1, (void *)2, 3, 4, (void *)5);
    check_ptr_parameter("IVRInput_007_GetActionBindingInfo", this_ptr_value);
    check_uint64_parameter("IVRInput_007_GetActionBindingInfo", 1);
    check_ptr_parameter("IVRInput_007_GetActionBindingInfo", (void *)2);
    check_uint32_parameter("IVRInput_007_GetActionBindingInfo", 3);
    check_uint32_parameter("IVRInput_007_GetActionBindingInfo", 4);
    check_ptr_parameter("IVRInput_007_GetActionBindingInfo", (void *)5);

    init_thunk(t, this_ptr_value, IVRInput_007_ShowActionOrigins, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_ShowActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_ShowActionOrigins(1, 2);
    check_ptr_parameter("IVRInput_007_ShowActionOrigins", this_ptr_value);
    check_uint64_parameter("IVRInput_007_ShowActionOrigins", 1);
    check_uint64_parameter("IVRInput_007_ShowActionOrigins", 2);

    init_thunk(t, this_ptr_value, IVRInput_007_ShowBindingsForActionSet, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_ShowBindingsForActionSet)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_ShowBindingsForActionSet((void *)1, 2, 3, 4);
    check_ptr_parameter("IVRInput_007_ShowBindingsForActionSet", this_ptr_value);
    check_ptr_parameter("IVRInput_007_ShowBindingsForActionSet", (void *)1);
    check_uint32_parameter("IVRInput_007_ShowBindingsForActionSet", 2);
    check_uint32_parameter("IVRInput_007_ShowBindingsForActionSet", 3);
    check_uint64_parameter("IVRInput_007_ShowBindingsForActionSet", 4);

    init_thunk(t, this_ptr_value, IVRInput_007_IsUsingLegacyInput, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRInput_007_IsUsingLegacyInput)() = (void *)t;

    clear_parameters();
    capi_IVRInput_007_IsUsingLegacyInput();
    check_ptr_parameter("IVRInput_007_IsUsingLegacyInput", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRInput_007_OpenBindingUI, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_007_OpenBindingUI)(const char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRInput_007_OpenBindingUI((void *)1, 2, 3, 1);
    check_ptr_parameter("IVRInput_007_OpenBindingUI", this_ptr_value);
    check_ptr_parameter("IVRInput_007_OpenBindingUI", (void *)1);
    check_uint64_parameter("IVRInput_007_OpenBindingUI", 2);
    check_uint64_parameter("IVRInput_007_OpenBindingUI", 3);
    check_bool_parameter("IVRInput_007_OpenBindingUI", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSettings_002(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSettings_002_GetSettingsErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSettings_002_GetSettingsErrorNameFromEnum)(EVRSettingsError eError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_002_GetSettingsErrorNameFromEnum(1);
    check_ptr_parameter("IVRSettings_002_GetSettingsErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSettings_002_GetSettingsErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSettings_002_Sync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSettings_002_Sync)(bool bForce, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_002_Sync(1, (void *)2);
    check_ptr_parameter("IVRSettings_002_Sync", this_ptr_value);
    check_bool_parameter("IVRSettings_002_Sync", 1);
    check_ptr_parameter("IVRSettings_002_Sync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSettings_002_SetBool, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_002_SetBool)(const char * pchSection, const char * pchSettingsKey, bool bValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_002_SetBool((void *)1, (void *)2, 1, (void *)4);
    check_ptr_parameter("IVRSettings_002_SetBool", this_ptr_value);
    check_ptr_parameter("IVRSettings_002_SetBool", (void *)1);
    check_ptr_parameter("IVRSettings_002_SetBool", (void *)2);
    check_bool_parameter("IVRSettings_002_SetBool", 1);
    check_ptr_parameter("IVRSettings_002_SetBool", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_002_SetInt32, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_002_SetInt32)(const char * pchSection, const char * pchSettingsKey, int32_t nValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_002_SetInt32((void *)1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSettings_002_SetInt32", this_ptr_value);
    check_ptr_parameter("IVRSettings_002_SetInt32", (void *)1);
    check_ptr_parameter("IVRSettings_002_SetInt32", (void *)2);
    check_uint32_parameter("IVRSettings_002_SetInt32", 3);
    check_ptr_parameter("IVRSettings_002_SetInt32", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_002_SetFloat, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSettings_002_SetFloat)(const char * pchSection, const char * pchSettingsKey, float flValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_002_SetFloat((void *)1, (void *)2, 3.0f, (void *)4);
    check_ptr_parameter("IVRSettings_002_SetFloat", this_ptr_value);
    check_ptr_parameter("IVRSettings_002_SetFloat", (void *)1);
    check_ptr_parameter("IVRSettings_002_SetFloat", (void *)2);
    check_float_parameter("IVRSettings_002_SetFloat", 3.0f);
    check_ptr_parameter("IVRSettings_002_SetFloat", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_002_SetString, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_002_SetString)(const char * pchSection, const char * pchSettingsKey, const char * pchValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_002_SetString((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSettings_002_SetString", this_ptr_value);
    check_ptr_parameter("IVRSettings_002_SetString", (void *)1);
    check_ptr_parameter("IVRSettings_002_SetString", (void *)2);
    check_ptr_parameter("IVRSettings_002_SetString", (void *)3);
    check_ptr_parameter("IVRSettings_002_SetString", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_002_GetBool, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSettings_002_GetBool)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_002_GetBool((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSettings_002_GetBool", this_ptr_value);
    check_ptr_parameter("IVRSettings_002_GetBool", (void *)1);
    check_ptr_parameter("IVRSettings_002_GetBool", (void *)2);
    check_ptr_parameter("IVRSettings_002_GetBool", (void *)3);

    init_thunk(t, this_ptr_value, IVRSettings_002_GetInt32, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSettings_002_GetInt32)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_002_GetInt32((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSettings_002_GetInt32", this_ptr_value);
    check_ptr_parameter("IVRSettings_002_GetInt32", (void *)1);
    check_ptr_parameter("IVRSettings_002_GetInt32", (void *)2);
    check_ptr_parameter("IVRSettings_002_GetInt32", (void *)3);

    init_thunk(t, this_ptr_value, IVRSettings_002_GetFloat, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSettings_002_GetFloat)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_002_GetFloat((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSettings_002_GetFloat", this_ptr_value);
    check_ptr_parameter("IVRSettings_002_GetFloat", (void *)1);
    check_ptr_parameter("IVRSettings_002_GetFloat", (void *)2);
    check_ptr_parameter("IVRSettings_002_GetFloat", (void *)3);

    init_thunk(t, this_ptr_value, IVRSettings_002_GetString, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_002_GetString)(const char * pchSection, const char * pchSettingsKey, char * pchValue, uint32_t unValueLen, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_002_GetString((void *)1, (void *)2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSettings_002_GetString", this_ptr_value);
    check_ptr_parameter("IVRSettings_002_GetString", (void *)1);
    check_ptr_parameter("IVRSettings_002_GetString", (void *)2);
    check_ptr_parameter("IVRSettings_002_GetString", (void *)3);
    check_uint32_parameter("IVRSettings_002_GetString", 4);
    check_ptr_parameter("IVRSettings_002_GetString", (void *)5);

    init_thunk(t, this_ptr_value, IVRSettings_002_RemoveSection, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_002_RemoveSection)(const char * pchSection, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_002_RemoveSection((void *)1, (void *)2);
    check_ptr_parameter("IVRSettings_002_RemoveSection", this_ptr_value);
    check_ptr_parameter("IVRSettings_002_RemoveSection", (void *)1);
    check_ptr_parameter("IVRSettings_002_RemoveSection", (void *)2);

    init_thunk(t, this_ptr_value, IVRSettings_002_RemoveKeyInSection, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_002_RemoveKeyInSection)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_002_RemoveKeyInSection((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSettings_002_RemoveKeyInSection", this_ptr_value);
    check_ptr_parameter("IVRSettings_002_RemoveKeyInSection", (void *)1);
    check_ptr_parameter("IVRSettings_002_RemoveKeyInSection", (void *)2);
    check_ptr_parameter("IVRSettings_002_RemoveKeyInSection", (void *)3);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_022(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_022_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_022_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_022_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_022_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_022_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_022_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_022_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_022_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_022_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_022_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_022_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_022_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_022_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_022_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_022_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_022_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_022_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_022_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_022_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_022_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_022_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_022_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_022_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_022_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_022_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_022_Submit", 1);
    check_ptr_parameter("IVRCompositor_022_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_022_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_022_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_022_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_022_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_022_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_022_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_022_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_022_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_022_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetFrameTimings, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_022_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetFrameTimings((void *)1, 2);
    check_ptr_parameter("IVRCompositor_022_GetFrameTimings", this_ptr_value);
    check_ptr_parameter("IVRCompositor_022_GetFrameTimings", (void *)1);
    check_uint32_parameter("IVRCompositor_022_GetFrameTimings", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_022_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_022_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetCumulativeStats, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetCumulativeStats((void *)1, 2);
    check_ptr_parameter("IVRCompositor_022_GetCumulativeStats", this_ptr_value);
    check_ptr_parameter("IVRCompositor_022_GetCumulativeStats", (void *)1);
    check_uint32_parameter("IVRCompositor_022_GetCumulativeStats", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_022_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_022_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_022_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_022_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_022_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_022_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_022_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_022_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_022_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetCurrentFadeColor, 2, FALSE, FALSE);
    HmdColor_t *(__stdcall *capi_IVRCompositor_022_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetCurrentFadeColor(data_ptr_value, 1);
    check_ptr_parameter("IVRCompositor_022_GetCurrentFadeColor", this_ptr_value);
    check_ptr_parameter("IVRCompositor_022_GetCurrentFadeColor", data_ptr_value);
    check_bool_parameter("IVRCompositor_022_GetCurrentFadeColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_022_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_022_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_022_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_022_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetCurrentGridAlpha, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_022_GetCurrentGridAlpha)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetCurrentGridAlpha();
    check_ptr_parameter("IVRCompositor_022_GetCurrentGridAlpha", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_022_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_022_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_022_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_022_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_022_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_022_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_022_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_022_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_CompositorQuit();
    check_ptr_parameter("IVRCompositor_022_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_022_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_IsFullscreen();
    check_ptr_parameter("IVRCompositor_022_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_022_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_022_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_022_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_022_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_022_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_CanRenderScene();
    check_ptr_parameter("IVRCompositor_022_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_022_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_022_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_022_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_022_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_022_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_022_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_022_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_022_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_022_ForceInterleavedReprojectionOn", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_022_ForceReconnectProcess, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_ForceReconnectProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_ForceReconnectProcess();
    check_ptr_parameter("IVRCompositor_022_ForceReconnectProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_SuspendRendering, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_SuspendRendering)(bool bSuspend) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_SuspendRendering(1);
    check_ptr_parameter("IVRCompositor_022_SuspendRendering", this_ptr_value);
    check_bool_parameter("IVRCompositor_022_SuspendRendering", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetMirrorTextureD3D11, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_022_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_022_GetMirrorTextureD3D11", this_ptr_value);
    check_uint32_parameter("IVRCompositor_022_GetMirrorTextureD3D11", 1);
    check_ptr_parameter("IVRCompositor_022_GetMirrorTextureD3D11", (void *)2);
    check_ptr_parameter("IVRCompositor_022_GetMirrorTextureD3D11", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_022_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_ReleaseMirrorTextureD3D11((void *)1);
    check_ptr_parameter("IVRCompositor_022_ReleaseMirrorTextureD3D11", this_ptr_value);
    check_ptr_parameter("IVRCompositor_022_ReleaseMirrorTextureD3D11", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetMirrorTextureGL, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_022_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetMirrorTextureGL(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_022_GetMirrorTextureGL", this_ptr_value);
    check_uint32_parameter("IVRCompositor_022_GetMirrorTextureGL", 1);
    check_ptr_parameter("IVRCompositor_022_GetMirrorTextureGL", (void *)2);
    check_ptr_parameter("IVRCompositor_022_GetMirrorTextureGL", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_022_ReleaseSharedGLTexture, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_022_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_ReleaseSharedGLTexture(1, (void *)2);
    check_ptr_parameter("IVRCompositor_022_ReleaseSharedGLTexture", this_ptr_value);
    check_uint32_parameter("IVRCompositor_022_ReleaseSharedGLTexture", 1);
    check_ptr_parameter("IVRCompositor_022_ReleaseSharedGLTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_022_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_LockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_022_LockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_022_LockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_022_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_UnlockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_022_UnlockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_022_UnlockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_022_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetVulkanInstanceExtensionsRequired((void *)1, 2);
    check_ptr_parameter("IVRCompositor_022_GetVulkanInstanceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_022_GetVulkanInstanceExtensionsRequired", (void *)1);
    check_uint32_parameter("IVRCompositor_022_GetVulkanInstanceExtensionsRequired", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_022_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_022_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRCompositor_022_GetVulkanDeviceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_022_GetVulkanDeviceExtensionsRequired", (void *)1);
    check_ptr_parameter("IVRCompositor_022_GetVulkanDeviceExtensionsRequired", (void *)2);
    check_uint32_parameter("IVRCompositor_022_GetVulkanDeviceExtensionsRequired", 3);

    init_thunk(t, this_ptr_value, IVRCompositor_022_SetExplicitTimingMode, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_022_SetExplicitTimingMode)(EVRCompositorTimingMode eTimingMode) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_SetExplicitTimingMode(1);
    check_ptr_parameter("IVRCompositor_022_SetExplicitTimingMode", this_ptr_value);
    check_uint32_parameter("IVRCompositor_022_SetExplicitTimingMode", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_022_SubmitExplicitTimingData, 0, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_022_SubmitExplicitTimingData)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_SubmitExplicitTimingData();
    check_ptr_parameter("IVRCompositor_022_SubmitExplicitTimingData", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_IsMotionSmoothingEnabled, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_022_IsMotionSmoothingEnabled)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_IsMotionSmoothingEnabled();
    check_ptr_parameter("IVRCompositor_022_IsMotionSmoothingEnabled", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_IsMotionSmoothingSupported, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_022_IsMotionSmoothingSupported)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_IsMotionSmoothingSupported();
    check_ptr_parameter("IVRCompositor_022_IsMotionSmoothingSupported", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_022_IsCurrentSceneFocusAppLoading, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_022_IsCurrentSceneFocusAppLoading)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_022_IsCurrentSceneFocusAppLoading();
    check_ptr_parameter("IVRCompositor_022_IsCurrentSceneFocusAppLoading", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_021(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_021_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_021_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_021_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_021_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_021_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_021_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_021_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_021_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_021_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_021_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_021_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_021_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_021_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_021_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_021_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_021_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_021_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_021_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayName, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayName(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_SetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayName", 1);
    check_ptr_parameter("IVROverlay_021_SetOverlayName", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_021_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_021_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_021_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_021_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_021_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_021_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_021_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_021_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_021_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_021_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_021_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_021_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_021_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_021_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_021_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_021_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_021_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_021_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_021_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_021_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_021_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_021_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_021_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_021_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_021_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTexelAspect, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayTexelAspect(1, 2.0f);
    check_ptr_parameter("IVROverlay_021_SetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayTexelAspect", 1);
    check_float_parameter("IVROverlay_021_SetOverlayTexelAspect", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTexelAspect, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayTexelAspect(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayTexelAspect", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayTexelAspect", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlaySortOrder(1, 2);
    check_ptr_parameter("IVROverlay_021_SetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlaySortOrder", 1);
    check_uint32_parameter("IVROverlay_021_SetOverlaySortOrder", 2);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlaySortOrder(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlaySortOrder", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlaySortOrder", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_021_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_021_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayCurvature, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float fCurvature) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayCurvature(1, 2.0f);
    check_ptr_parameter("IVROverlay_021_SetOverlayCurvature", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayCurvature", 1);
    check_float_parameter("IVROverlay_021_SetOverlayCurvature", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayCurvature, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float * pfCurvature) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayCurvature(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayCurvature", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayCurvature", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayCurvature", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_021_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_021_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_021_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayRenderModel, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_021_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_021_GetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayRenderModel", (void *)2);
    check_uint32_parameter("IVROverlay_021_GetOverlayRenderModel", 3);
    check_ptr_parameter("IVROverlay_021_GetOverlayRenderModel", (void *)4);
    check_ptr_parameter("IVROverlay_021_GetOverlayRenderModel", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayRenderModel, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayRenderModel(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_021_SetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_021_SetOverlayRenderModel", (void *)2);
    check_ptr_parameter("IVROverlay_021_SetOverlayRenderModel", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_021_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_021_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_021_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayTransformOverlayRelative", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformOverlayRelative", (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_021_SetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayTransformOverlayRelative", 1);
    check_uint64_parameter("IVROverlay_021_SetOverlayTransformOverlayRelative", 2);
    check_ptr_parameter("IVROverlay_021_SetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_021_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_021_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_021_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_HideOverlay(1);
    check_ptr_parameter("IVROverlay_021_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_021_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_021_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_021_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_021_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_021_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_021_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_021_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_021_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_021_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_021_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_021_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_021_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_021_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_021_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_021_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_021_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_021_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_021_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_021_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_021_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_021_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_021_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayDualAnalogTransform, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayDualAnalogTransform(1, 2, (void *)3, 4.0f);
    check_ptr_parameter("IVROverlay_021_SetOverlayDualAnalogTransform", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayDualAnalogTransform", 1);
    check_uint32_parameter("IVROverlay_021_SetOverlayDualAnalogTransform", 2);
    check_ptr_parameter("IVROverlay_021_SetOverlayDualAnalogTransform", (void *)3);
    check_float_parameter("IVROverlay_021_SetOverlayDualAnalogTransform", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayDualAnalogTransform, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayDualAnalogTransform(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_021_GetOverlayDualAnalogTransform", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayDualAnalogTransform", 1);
    check_uint32_parameter("IVROverlay_021_GetOverlayDualAnalogTransform", 2);
    check_ptr_parameter("IVROverlay_021_GetOverlayDualAnalogTransform", (void *)3);
    check_ptr_parameter("IVROverlay_021_GetOverlayDualAnalogTransform", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_021_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_021_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_021_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_021_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_021_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_021_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_021_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_021_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTexture, 9, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)8);
    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)9);

    init_thunk(t, this_ptr_value, IVROverlay_021_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_021_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTextureSize, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayTextureSize(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_021_GetOverlayTextureSize", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayTextureSize", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayTextureSize", (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayTextureSize", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_021_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_021_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_021_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_021_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_021_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_021_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_021_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_021_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_021_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_021_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_021_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_021_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_021_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_021_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_021_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_021_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_021_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_021_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_021_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_021_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_021_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_021_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_021_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_021_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_021_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_021_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_021_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_021_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_021_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_021_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_021_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_021_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_021_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_021_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_021_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_021_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_021_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_021_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_021_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_021_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_021_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_021_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_021_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_021_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_HideKeyboard();
    check_ptr_parameter("IVROverlay_021_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_021_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_021_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_021_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_021_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_021_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_021_SetKeyboardPositionForOverlay", DEFAULT_RECT);

    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayIntersectionMask, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
    check_ptr_parameter("IVROverlay_021_SetOverlayIntersectionMask", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_SetOverlayIntersectionMask", 1);
    check_ptr_parameter("IVROverlay_021_SetOverlayIntersectionMask", (void *)2);
    check_uint32_parameter("IVROverlay_021_SetOverlayIntersectionMask", 3);
    check_uint32_parameter("IVROverlay_021_SetOverlayIntersectionMask", 4);

    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayFlags, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_GetOverlayFlags(1, (void *)2);
    check_ptr_parameter("IVROverlay_021_GetOverlayFlags", this_ptr_value);
    check_uint64_parameter("IVROverlay_021_GetOverlayFlags", 1);
    check_ptr_parameter("IVROverlay_021_GetOverlayFlags", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_021_ShowMessageOverlay, 6, FALSE, FALSE);
    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_021_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", (void *)4);
    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", (void *)5);
    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", (void *)6);

    init_thunk(t, this_ptr_value, IVROverlay_021_CloseMessageOverlay, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_021_CloseMessageOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_021_CloseMessageOverlay();
    check_ptr_parameter("IVROverlay_021_CloseMessageOverlay", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_020(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_020_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_020_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_020_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetProjectionMatrix, 4, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_020_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_020_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_020_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_020_GetProjectionMatrix", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_020_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_020_ComputeDistortion, 4, TRUE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
    check_ptr_parameter("IVRSystem_020_ComputeDistortion", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_020_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_020_ComputeDistortion", 3.0f);
    check_ptr_parameter("IVRSystem_020_ComputeDistortion", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_020_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_020_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_020_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_020_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_020_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_020_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetDXGIOutputInfo, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_020_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetDXGIOutputInfo((void *)1);
    check_ptr_parameter("IVRSystem_020_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetDXGIOutputInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetOutputDevice, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_020_GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetOutputDevice((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_020_GetOutputDevice", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetOutputDevice", (void *)1);
    check_uint32_parameter("IVRSystem_020_GetOutputDevice", 2);
    check_ptr_parameter("IVRSystem_020_GetOutputDevice", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_020_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_020_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_020_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_020_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_020_SetDisplayVisibility", 1);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_020_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_020_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_020_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_020_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_020_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_020_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_020_ApplyTransform, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_020_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_ApplyTransform((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_020_ApplyTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_ApplyTransform", (void *)1);
    check_ptr_parameter("IVRSystem_020_ApplyTransform", (void *)2);
    check_ptr_parameter("IVRSystem_020_ApplyTransform", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_020_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetTrackedDeviceIndexForControllerRole(1);
    check_ptr_parameter("IVRSystem_020_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetTrackedDeviceIndexForControllerRole", 1);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
    ETrackedControllerRole (__stdcall *capi_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex(1);
    check_ptr_parameter("IVRSystem_020_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetControllerRoleForTrackedDeviceIndex", 1);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetTrackedDeviceClass, 1, FALSE, FALSE);
    ETrackedDeviceClass (__stdcall *capi_IVRSystem_020_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_020_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_020_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_020_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_020_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_020_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_020_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_020_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_020_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_020_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_020_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_020_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_020_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_020_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_020_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_020_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_020_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_020_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_020_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_020_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetArrayTrackedDeviceProperty, 6, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_020_GetArrayTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetArrayTrackedDeviceProperty(1, 2, 3, (void *)4, 5, (void *)6);
    check_ptr_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", 2);
    check_uint32_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", 3);
    check_ptr_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", (void *)4);
    check_uint32_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", 5);
    check_ptr_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", (void *)6);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_020_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_020_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_020_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_020_PollNextEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_PollNextEvent((void *)1, 2);
    check_ptr_parameter("IVRSystem_020_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_PollNextEvent", (void *)1);
    check_uint32_parameter("IVRSystem_020_PollNextEvent", 2);

    init_thunk(t, this_ptr_value, IVRSystem_020_PollNextEventWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSystem_020_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_020_PollNextEventWithPose", (void *)2);
    check_uint32_parameter("IVRSystem_020_PollNextEventWithPose", 3);
    check_ptr_parameter("IVRSystem_020_PollNextEventWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_020_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_020_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetHiddenAreaMesh, 3, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_020_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetHiddenAreaMesh(data_ptr_value, 1, 2);
    check_ptr_parameter("IVRSystem_020_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetHiddenAreaMesh", 1);
    check_uint32_parameter("IVRSystem_020_GetHiddenAreaMesh", 2);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetControllerState, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetControllerState(1, (void *)2, 3);
    check_ptr_parameter("IVRSystem_020_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_020_GetControllerState", (void *)2);
    check_uint32_parameter("IVRSystem_020_GetControllerState", 3);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetControllerStateWithPose, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_020_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_020_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_020_GetControllerStateWithPose", (void *)3);
    check_uint32_parameter("IVRSystem_020_GetControllerStateWithPose", 4);
    check_ptr_parameter("IVRSystem_020_GetControllerStateWithPose", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_020_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_020_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_020_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_020_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_020_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_020_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_020_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_020_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_020_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_020_IsInputAvailable, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_IsInputAvailable)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_IsInputAvailable();
    check_ptr_parameter("IVRSystem_020_IsInputAvailable", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_020_IsSteamVRDrawingControllers, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_IsSteamVRDrawingControllers)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_IsSteamVRDrawingControllers();
    check_ptr_parameter("IVRSystem_020_IsSteamVRDrawingControllers", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_020_ShouldApplicationPause, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_ShouldApplicationPause)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_ShouldApplicationPause();
    check_ptr_parameter("IVRSystem_020_ShouldApplicationPause", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_020_ShouldApplicationReduceRenderingWork, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_020_ShouldApplicationReduceRenderingWork)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_ShouldApplicationReduceRenderingWork();
    check_ptr_parameter("IVRSystem_020_ShouldApplicationReduceRenderingWork", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_020_PerformFirmwareUpdate, 1, FALSE, FALSE);
    EVRFirmwareError (__stdcall *capi_IVRSystem_020_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_020_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_020_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_020_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_020_AcknowledgeQuit_Exiting)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_AcknowledgeQuit_Exiting();
    check_ptr_parameter("IVRSystem_020_AcknowledgeQuit_Exiting", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_020_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_020_AcknowledgeQuit_UserPrompt)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_AcknowledgeQuit_UserPrompt();
    check_ptr_parameter("IVRSystem_020_AcknowledgeQuit_UserPrompt", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetAppContainerFilePaths, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_020_GetAppContainerFilePaths)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetAppContainerFilePaths((void *)1, 2);
    check_ptr_parameter("IVRSystem_020_GetAppContainerFilePaths", this_ptr_value);
    check_ptr_parameter("IVRSystem_020_GetAppContainerFilePaths", (void *)1);
    check_uint32_parameter("IVRSystem_020_GetAppContainerFilePaths", 2);

    init_thunk(t, this_ptr_value, IVRSystem_020_GetRuntimeVersion, 0, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_020_GetRuntimeVersion)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_020_GetRuntimeVersion();
    check_ptr_parameter("IVRSystem_020_GetRuntimeVersion", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRApplications_006(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRApplications_006_AddApplicationManifest, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_AddApplicationManifest((void *)1, 1);
    check_ptr_parameter("IVRApplications_006_AddApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_AddApplicationManifest", (void *)1);
    check_bool_parameter("IVRApplications_006_AddApplicationManifest", 1);

    init_thunk(t, this_ptr_value, IVRApplications_006_RemoveApplicationManifest, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_RemoveApplicationManifest((void *)1);
    check_ptr_parameter("IVRApplications_006_RemoveApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_RemoveApplicationManifest", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_006_IsApplicationInstalled, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_006_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_IsApplicationInstalled((void *)1);
    check_ptr_parameter("IVRApplications_006_IsApplicationInstalled", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_IsApplicationInstalled", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationCount)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationCount();
    check_ptr_parameter("IVRApplications_006_GetApplicationCount", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationKeyByIndex, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationKeyByIndex(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByIndex", this_ptr_value);
    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByIndex", 1);
    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByIndex", (void *)2);
    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByIndex", 3);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationKeyByProcessId(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByProcessId", this_ptr_value);
    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByProcessId", 1);
    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByProcessId", (void *)2);
    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByProcessId", 3);

    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchApplication, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchApplication)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_LaunchApplication((void *)1);
    check_ptr_parameter("IVRApplications_006_LaunchApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_LaunchApplication", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchTemplateApplication, 4, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchTemplateApplication)(const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_LaunchTemplateApplication((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", (void *)1);
    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", (void *)2);
    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", (void *)3);
    check_uint32_parameter("IVRApplications_006_LaunchTemplateApplication", 4);

    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchApplicationFromMimeType, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchApplicationFromMimeType)(const char * pchMimeType, const char * pchArgs) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_LaunchApplicationFromMimeType((void *)1, (void *)2);
    check_ptr_parameter("IVRApplications_006_LaunchApplicationFromMimeType", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_LaunchApplicationFromMimeType", (void *)1);
    check_ptr_parameter("IVRApplications_006_LaunchApplicationFromMimeType", (void *)2);

    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchDashboardOverlay, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_LaunchDashboardOverlay((void *)1);
    check_ptr_parameter("IVRApplications_006_LaunchDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_LaunchDashboardOverlay", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_006_CancelApplicationLaunch, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_006_CancelApplicationLaunch)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_CancelApplicationLaunch((void *)1);
    check_ptr_parameter("IVRApplications_006_CancelApplicationLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_CancelApplicationLaunch", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_006_IdentifyApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_IdentifyApplication(1, (void *)2);
    check_ptr_parameter("IVRApplications_006_IdentifyApplication", this_ptr_value);
    check_uint32_parameter("IVRApplications_006_IdentifyApplication", 1);
    check_ptr_parameter("IVRApplications_006_IdentifyApplication", (void *)2);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationProcessId, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationProcessId((void *)1);
    check_ptr_parameter("IVRApplications_006_GetApplicationProcessId", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_GetApplicationProcessId", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_006_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationsErrorNameFromEnum(1);
    check_ptr_parameter("IVRApplications_006_GetApplicationsErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_006_GetApplicationsErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationPropertyString, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", (void *)1);
    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyString", 2);
    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", (void *)3);
    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyString", 4);
    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", (void *)5);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationPropertyBool, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_006_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationPropertyBool((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyBool", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyBool", (void *)1);
    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyBool", 2);
    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyBool", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationPropertyUint64, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRApplications_006_GetApplicationPropertyUint64)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationPropertyUint64((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyUint64", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyUint64", (void *)1);
    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyUint64", 2);
    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyUint64", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_006_SetApplicationAutoLaunch, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_SetApplicationAutoLaunch((void *)1, 1);
    check_ptr_parameter("IVRApplications_006_SetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_SetApplicationAutoLaunch", (void *)1);
    check_bool_parameter("IVRApplications_006_SetApplicationAutoLaunch", 1);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationAutoLaunch, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_006_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationAutoLaunch((void *)1);
    check_ptr_parameter("IVRApplications_006_GetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_GetApplicationAutoLaunch", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_006_SetDefaultApplicationForMimeType, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_SetDefaultApplicationForMimeType)(const char * pchAppKey, const char * pchMimeType) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_SetDefaultApplicationForMimeType((void *)1, (void *)2);
    check_ptr_parameter("IVRApplications_006_SetDefaultApplicationForMimeType", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_SetDefaultApplicationForMimeType", (void *)1);
    check_ptr_parameter("IVRApplications_006_SetDefaultApplicationForMimeType", (void *)2);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetDefaultApplicationForMimeType, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_006_GetDefaultApplicationForMimeType)(const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetDefaultApplicationForMimeType((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", (void *)1);
    check_ptr_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", (void *)2);
    check_uint32_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", 3);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationSupportedMimeTypes, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_006_GetApplicationSupportedMimeTypes)(const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationSupportedMimeTypes((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", (void *)1);
    check_ptr_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", (void *)2);
    check_uint32_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", 3);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationsThatSupportMimeType, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationsThatSupportMimeType)(const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationsThatSupportMimeType((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", (void *)1);
    check_ptr_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", (void *)2);
    check_uint32_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", 3);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationLaunchArguments, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationLaunchArguments)(uint32_t unHandle, char * pchArgs, uint32_t unArgs) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationLaunchArguments(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_006_GetApplicationLaunchArguments", this_ptr_value);
    check_uint32_parameter("IVRApplications_006_GetApplicationLaunchArguments", 1);
    check_ptr_parameter("IVRApplications_006_GetApplicationLaunchArguments", (void *)2);
    check_uint32_parameter("IVRApplications_006_GetApplicationLaunchArguments", 3);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetStartingApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetStartingApplication((void *)1, 2);
    check_ptr_parameter("IVRApplications_006_GetStartingApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_GetStartingApplication", (void *)1);
    check_uint32_parameter("IVRApplications_006_GetStartingApplication", 2);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetTransitionState, 0, FALSE, FALSE);
    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_006_GetTransitionState)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetTransitionState();
    check_ptr_parameter("IVRApplications_006_GetTransitionState", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_006_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_PerformApplicationPrelaunchCheck((void *)1);
    check_ptr_parameter("IVRApplications_006_PerformApplicationPrelaunchCheck", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_PerformApplicationPrelaunchCheck", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_006_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetApplicationsTransitionStateNameFromEnum(1);
    check_ptr_parameter("IVRApplications_006_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_006_GetApplicationsTransitionStateNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_006_IsQuitUserPromptRequested, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_006_IsQuitUserPromptRequested)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_IsQuitUserPromptRequested();
    check_ptr_parameter("IVRApplications_006_IsQuitUserPromptRequested", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchInternalProcess, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchInternalProcess)(const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory) = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_LaunchInternalProcess((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", this_ptr_value);
    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", (void *)1);
    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", (void *)2);
    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_006_GetCurrentSceneProcessId, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_006_GetCurrentSceneProcessId)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_006_GetCurrentSceneProcessId();
    check_ptr_parameter("IVRApplications_006_GetCurrentSceneProcessId", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_020(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_020_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_020_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_020_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_020_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_020_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_020_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_020_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_020_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_020_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_020_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_020_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_020_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_020_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_020_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_020_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_020_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_020_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayName, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayName(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_SetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayName", 1);
    check_ptr_parameter("IVROverlay_020_SetOverlayName", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_020_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_020_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_020_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_020_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_020_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_020_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_020_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_020_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_020_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_020_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_020_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_020_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_020_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_020_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_020_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_020_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_020_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_020_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_020_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_020_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_020_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_020_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_020_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_020_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_020_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTexelAspect, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayTexelAspect(1, 2.0f);
    check_ptr_parameter("IVROverlay_020_SetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayTexelAspect", 1);
    check_float_parameter("IVROverlay_020_SetOverlayTexelAspect", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTexelAspect, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayTexelAspect(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayTexelAspect", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayTexelAspect", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlaySortOrder(1, 2);
    check_ptr_parameter("IVROverlay_020_SetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlaySortOrder", 1);
    check_uint32_parameter("IVROverlay_020_SetOverlaySortOrder", 2);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlaySortOrder(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlaySortOrder", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlaySortOrder", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_020_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_020_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_020_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_020_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_020_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayRenderModel, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_020_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_020_GetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayRenderModel", (void *)2);
    check_uint32_parameter("IVROverlay_020_GetOverlayRenderModel", 3);
    check_ptr_parameter("IVROverlay_020_GetOverlayRenderModel", (void *)4);
    check_ptr_parameter("IVROverlay_020_GetOverlayRenderModel", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayRenderModel, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayRenderModel(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_020_SetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_020_SetOverlayRenderModel", (void *)2);
    check_ptr_parameter("IVROverlay_020_SetOverlayRenderModel", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_020_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_020_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_020_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayTransformOverlayRelative", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformOverlayRelative", (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_020_SetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayTransformOverlayRelative", 1);
    check_uint64_parameter("IVROverlay_020_SetOverlayTransformOverlayRelative", 2);
    check_ptr_parameter("IVROverlay_020_SetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_020_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_020_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_HideOverlay(1);
    check_ptr_parameter("IVROverlay_020_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_020_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_020_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_020_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_020_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_020_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_020_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_020_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_020_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_020_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_020_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_020_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_020_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_020_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_020_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_020_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_020_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_020_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetGamepadFocusOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_020_GetGamepadFocusOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetGamepadFocusOverlay();
    check_ptr_parameter("IVROverlay_020_GetGamepadFocusOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetGamepadFocusOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetGamepadFocusOverlay(1);
    check_ptr_parameter("IVROverlay_020_SetGamepadFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetGamepadFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayNeighbor, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayNeighbor(1, 2, 3);
    check_ptr_parameter("IVROverlay_020_SetOverlayNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_020_SetOverlayNeighbor", 1);
    check_uint64_parameter("IVROverlay_020_SetOverlayNeighbor", 2);
    check_uint64_parameter("IVROverlay_020_SetOverlayNeighbor", 3);

    init_thunk(t, this_ptr_value, IVROverlay_020_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_MoveGamepadFocusToNeighbor(1, 2);
    check_ptr_parameter("IVROverlay_020_MoveGamepadFocusToNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_020_MoveGamepadFocusToNeighbor", 1);
    check_uint64_parameter("IVROverlay_020_MoveGamepadFocusToNeighbor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayDualAnalogTransform, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayDualAnalogTransform(1, 2, (void *)3, 4.0f);
    check_ptr_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", 1);
    check_uint32_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", 2);
    check_ptr_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", (void *)3);
    check_float_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayDualAnalogTransform, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayDualAnalogTransform(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", 1);
    check_uint32_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", 2);
    check_ptr_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", (void *)3);
    check_ptr_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_020_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_020_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_020_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_020_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_020_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_020_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_020_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_020_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTexture, 9, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)8);
    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)9);

    init_thunk(t, this_ptr_value, IVROverlay_020_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_020_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTextureSize, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayTextureSize(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_020_GetOverlayTextureSize", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayTextureSize", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayTextureSize", (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayTextureSize", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_020_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_020_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_020_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_020_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_020_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_020_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_020_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_020_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_020_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_020_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_020_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_020_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_020_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_020_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_020_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_020_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_020_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_020_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_020_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_020_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_020_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_020_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_020_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_020_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_020_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_020_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_020_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_020_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_020_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_020_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_020_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_020_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_020_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_020_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_020_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_020_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_020_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_020_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_020_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_HideKeyboard();
    check_ptr_parameter("IVROverlay_020_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_020_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_020_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_020_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_020_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_020_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_020_SetKeyboardPositionForOverlay", DEFAULT_RECT);

    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayIntersectionMask, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
    check_ptr_parameter("IVROverlay_020_SetOverlayIntersectionMask", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_SetOverlayIntersectionMask", 1);
    check_ptr_parameter("IVROverlay_020_SetOverlayIntersectionMask", (void *)2);
    check_uint32_parameter("IVROverlay_020_SetOverlayIntersectionMask", 3);
    check_uint32_parameter("IVROverlay_020_SetOverlayIntersectionMask", 4);

    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayFlags, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_GetOverlayFlags(1, (void *)2);
    check_ptr_parameter("IVROverlay_020_GetOverlayFlags", this_ptr_value);
    check_uint64_parameter("IVROverlay_020_GetOverlayFlags", 1);
    check_ptr_parameter("IVROverlay_020_GetOverlayFlags", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_020_ShowMessageOverlay, 6, FALSE, FALSE);
    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_020_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)4);
    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)5);
    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)6);

    init_thunk(t, this_ptr_value, IVROverlay_020_CloseMessageOverlay, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_020_CloseMessageOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_020_CloseMessageOverlay();
    check_ptr_parameter("IVROverlay_020_CloseMessageOverlay", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_019(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_019_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_019_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_019_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_019_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_019_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_019_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_019_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_019_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_019_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetHighQualityOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_019_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_019_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_019_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_019_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_019_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_019_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_019_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_019_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_019_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_019_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_019_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayName, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayName(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_SetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayName", 1);
    check_ptr_parameter("IVROverlay_019_SetOverlayName", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_019_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_019_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_019_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_019_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_019_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_019_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_019_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_019_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_019_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_019_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_019_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_019_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_019_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_019_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_019_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_019_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_019_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_019_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_019_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_019_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_019_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_019_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_019_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_019_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_019_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayTexelAspect, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayTexelAspect(1, 2.0f);
    check_ptr_parameter("IVROverlay_019_SetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayTexelAspect", 1);
    check_float_parameter("IVROverlay_019_SetOverlayTexelAspect", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayTexelAspect, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayTexelAspect(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayTexelAspect", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayTexelAspect", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlaySortOrder(1, 2);
    check_ptr_parameter("IVROverlay_019_SetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlaySortOrder", 1);
    check_uint32_parameter("IVROverlay_019_SetOverlaySortOrder", 2);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlaySortOrder(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlaySortOrder", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlaySortOrder", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_019_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_019_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_019_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_019_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_019_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_019_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_019_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_019_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_019_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayRenderModel, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_019_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_019_GetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayRenderModel", (void *)2);
    check_uint32_parameter("IVROverlay_019_GetOverlayRenderModel", 3);
    check_ptr_parameter("IVROverlay_019_GetOverlayRenderModel", (void *)4);
    check_ptr_parameter("IVROverlay_019_GetOverlayRenderModel", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayRenderModel, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayRenderModel(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_019_SetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_019_SetOverlayRenderModel", (void *)2);
    check_ptr_parameter("IVROverlay_019_SetOverlayRenderModel", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_019_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_019_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_019_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_019_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_019_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_019_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_019_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_019_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_019_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_019_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayTransformOverlayRelative", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformOverlayRelative", (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_019_SetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayTransformOverlayRelative", 1);
    check_uint64_parameter("IVROverlay_019_SetOverlayTransformOverlayRelative", 2);
    check_ptr_parameter("IVROverlay_019_SetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_019_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_019_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_HideOverlay(1);
    check_ptr_parameter("IVROverlay_019_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_019_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_019_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_019_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_019_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_019_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_019_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_019_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_019_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_019_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_019_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_019_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_019_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_019_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_019_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_019_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_019_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_019_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_019_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_019_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_019_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_019_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetGamepadFocusOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_019_GetGamepadFocusOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetGamepadFocusOverlay();
    check_ptr_parameter("IVROverlay_019_GetGamepadFocusOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetGamepadFocusOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetGamepadFocusOverlay(1);
    check_ptr_parameter("IVROverlay_019_SetGamepadFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetGamepadFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayNeighbor, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayNeighbor(1, 2, 3);
    check_ptr_parameter("IVROverlay_019_SetOverlayNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_019_SetOverlayNeighbor", 1);
    check_uint64_parameter("IVROverlay_019_SetOverlayNeighbor", 2);
    check_uint64_parameter("IVROverlay_019_SetOverlayNeighbor", 3);

    init_thunk(t, this_ptr_value, IVROverlay_019_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_MoveGamepadFocusToNeighbor(1, 2);
    check_ptr_parameter("IVROverlay_019_MoveGamepadFocusToNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_019_MoveGamepadFocusToNeighbor", 1);
    check_uint64_parameter("IVROverlay_019_MoveGamepadFocusToNeighbor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayDualAnalogTransform, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayDualAnalogTransform(1, 2, (void *)3, 4.0f);
    check_ptr_parameter("IVROverlay_019_SetOverlayDualAnalogTransform", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayDualAnalogTransform", 1);
    check_uint32_parameter("IVROverlay_019_SetOverlayDualAnalogTransform", 2);
    check_ptr_parameter("IVROverlay_019_SetOverlayDualAnalogTransform", (void *)3);
    check_float_parameter("IVROverlay_019_SetOverlayDualAnalogTransform", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayDualAnalogTransform, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayDualAnalogTransform(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_019_GetOverlayDualAnalogTransform", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayDualAnalogTransform", 1);
    check_uint32_parameter("IVROverlay_019_GetOverlayDualAnalogTransform", 2);
    check_ptr_parameter("IVROverlay_019_GetOverlayDualAnalogTransform", (void *)3);
    check_ptr_parameter("IVROverlay_019_GetOverlayDualAnalogTransform", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_019_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_019_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_019_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_019_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_019_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_019_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_019_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_019_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayTexture, 9, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
    check_ptr_parameter("IVROverlay_019_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_019_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_019_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_019_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_019_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_019_GetOverlayTexture", (void *)8);
    check_ptr_parameter("IVROverlay_019_GetOverlayTexture", (void *)9);

    init_thunk(t, this_ptr_value, IVROverlay_019_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_019_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayTextureSize, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayTextureSize(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_019_GetOverlayTextureSize", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayTextureSize", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayTextureSize", (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayTextureSize", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_019_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_019_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_019_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_019_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_019_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_019_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_019_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_019_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_019_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_019_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_019_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_019_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_019_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_019_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_019_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_019_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_019_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_019_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_019_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_019_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_019_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_019_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_019_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_019_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_019_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_019_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_019_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_019_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_019_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_019_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_019_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_019_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_019_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_019_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_019_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_019_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_019_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_019_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_019_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_019_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_019_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_019_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_019_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_019_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_HideKeyboard();
    check_ptr_parameter("IVROverlay_019_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_019_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_019_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_019_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_019_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_019_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_019_SetKeyboardPositionForOverlay", DEFAULT_RECT);

    init_thunk(t, this_ptr_value, IVROverlay_019_SetOverlayIntersectionMask, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
    check_ptr_parameter("IVROverlay_019_SetOverlayIntersectionMask", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_SetOverlayIntersectionMask", 1);
    check_ptr_parameter("IVROverlay_019_SetOverlayIntersectionMask", (void *)2);
    check_uint32_parameter("IVROverlay_019_SetOverlayIntersectionMask", 3);
    check_uint32_parameter("IVROverlay_019_SetOverlayIntersectionMask", 4);

    init_thunk(t, this_ptr_value, IVROverlay_019_GetOverlayFlags, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_019_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_GetOverlayFlags(1, (void *)2);
    check_ptr_parameter("IVROverlay_019_GetOverlayFlags", this_ptr_value);
    check_uint64_parameter("IVROverlay_019_GetOverlayFlags", 1);
    check_ptr_parameter("IVROverlay_019_GetOverlayFlags", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_019_ShowMessageOverlay, 6, FALSE, FALSE);
    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_019_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
    check_ptr_parameter("IVROverlay_019_ShowMessageOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_019_ShowMessageOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_019_ShowMessageOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_019_ShowMessageOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_019_ShowMessageOverlay", (void *)4);
    check_ptr_parameter("IVROverlay_019_ShowMessageOverlay", (void *)5);
    check_ptr_parameter("IVROverlay_019_ShowMessageOverlay", (void *)6);

    init_thunk(t, this_ptr_value, IVROverlay_019_CloseMessageOverlay, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_019_CloseMessageOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_019_CloseMessageOverlay();
    check_ptr_parameter("IVROverlay_019_CloseMessageOverlay", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRTrackedCamera_005(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_005_GetCameraErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRTrackedCamera_005_GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_005_GetCameraErrorNameFromEnum(1);
    check_ptr_parameter("IVRTrackedCamera_005_GetCameraErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_005_GetCameraErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_005_HasCamera, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_005_HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_005_HasCamera(1, (void *)2);
    check_ptr_parameter("IVRTrackedCamera_005_HasCamera", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_005_HasCamera", 1);
    check_ptr_parameter("IVRTrackedCamera_005_HasCamera", (void *)2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_005_GetCameraFrameSize, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_005_GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_005_GetCameraFrameSize(1, 2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_005_GetCameraFrameSize", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_005_GetCameraFrameSize", 1);
    check_uint32_parameter("IVRTrackedCamera_005_GetCameraFrameSize", 2);
    check_ptr_parameter("IVRTrackedCamera_005_GetCameraFrameSize", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_005_GetCameraFrameSize", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_005_GetCameraFrameSize", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_005_GetCameraIntrinsics, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_005_GetCameraIntrinsics)(TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_005_GetCameraIntrinsics(1, 2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_005_GetCameraIntrinsics", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_005_GetCameraIntrinsics", 1);
    check_uint32_parameter("IVRTrackedCamera_005_GetCameraIntrinsics", 2);
    check_uint32_parameter("IVRTrackedCamera_005_GetCameraIntrinsics", 3);
    check_ptr_parameter("IVRTrackedCamera_005_GetCameraIntrinsics", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_005_GetCameraIntrinsics", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_005_GetCameraProjection, 6, TRUE, TRUE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_005_GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_005_GetCameraProjection(1, 2, 3, 4.0f, 5.0f, (void *)6);
    check_ptr_parameter("IVRTrackedCamera_005_GetCameraProjection", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_005_GetCameraProjection", 1);
    check_uint32_parameter("IVRTrackedCamera_005_GetCameraProjection", 2);
    check_uint32_parameter("IVRTrackedCamera_005_GetCameraProjection", 3);
    check_float_parameter("IVRTrackedCamera_005_GetCameraProjection", 4.0f);
    check_float_parameter("IVRTrackedCamera_005_GetCameraProjection", 5.0f);
    check_ptr_parameter("IVRTrackedCamera_005_GetCameraProjection", (void *)6);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_005_AcquireVideoStreamingService, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_005_AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_005_AcquireVideoStreamingService(1, (void *)2);
    check_ptr_parameter("IVRTrackedCamera_005_AcquireVideoStreamingService", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_005_AcquireVideoStreamingService", 1);
    check_ptr_parameter("IVRTrackedCamera_005_AcquireVideoStreamingService", (void *)2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_005_ReleaseVideoStreamingService, 1, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_005_ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_005_ReleaseVideoStreamingService(1);
    check_ptr_parameter("IVRTrackedCamera_005_ReleaseVideoStreamingService", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_005_ReleaseVideoStreamingService", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_005_GetVideoStreamFrameBuffer, 6, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_005_GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_005_GetVideoStreamFrameBuffer(1, 2, (void *)3, 4, (void *)5, 6);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamFrameBuffer", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_005_GetVideoStreamFrameBuffer", 1);
    check_uint32_parameter("IVRTrackedCamera_005_GetVideoStreamFrameBuffer", 2);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamFrameBuffer", (void *)3);
    check_uint32_parameter("IVRTrackedCamera_005_GetVideoStreamFrameBuffer", 4);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamFrameBuffer", (void *)5);
    check_uint32_parameter("IVRTrackedCamera_005_GetVideoStreamFrameBuffer", 6);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_005_GetVideoStreamTextureSize, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_005_GetVideoStreamTextureSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_005_GetVideoStreamTextureSize(1, 2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamTextureSize", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_005_GetVideoStreamTextureSize", 1);
    check_uint32_parameter("IVRTrackedCamera_005_GetVideoStreamTextureSize", 2);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamTextureSize", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamTextureSize", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamTextureSize", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_005_GetVideoStreamTextureD3D11, 6, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_005_GetVideoStreamTextureD3D11)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_005_GetVideoStreamTextureD3D11(1, 2, (void *)3, (void *)4, (void *)5, 6);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamTextureD3D11", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_005_GetVideoStreamTextureD3D11", 1);
    check_uint32_parameter("IVRTrackedCamera_005_GetVideoStreamTextureD3D11", 2);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamTextureD3D11", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamTextureD3D11", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamTextureD3D11", (void *)5);
    check_uint32_parameter("IVRTrackedCamera_005_GetVideoStreamTextureD3D11", 6);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_005_GetVideoStreamTextureGL, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_005_GetVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_005_GetVideoStreamTextureGL(1, 2, (void *)3, (void *)4, 5);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamTextureGL", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_005_GetVideoStreamTextureGL", 1);
    check_uint32_parameter("IVRTrackedCamera_005_GetVideoStreamTextureGL", 2);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamTextureGL", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_005_GetVideoStreamTextureGL", (void *)4);
    check_uint32_parameter("IVRTrackedCamera_005_GetVideoStreamTextureGL", 5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_005_ReleaseVideoStreamTextureGL, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_005_ReleaseVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_005_ReleaseVideoStreamTextureGL(1, 2);
    check_ptr_parameter("IVRTrackedCamera_005_ReleaseVideoStreamTextureGL", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_005_ReleaseVideoStreamTextureGL", 1);
    check_uint32_parameter("IVRTrackedCamera_005_ReleaseVideoStreamTextureGL", 2);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_019(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_019_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_019_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_019_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_019_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetProjectionMatrix, 4, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_019_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_019_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_019_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_019_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_019_GetProjectionMatrix", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_019_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_019_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_019_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_019_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_019_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_019_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_019_ComputeDistortion, 4, TRUE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
    check_ptr_parameter("IVRSystem_019_ComputeDistortion", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_019_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_019_ComputeDistortion", 3.0f);
    check_ptr_parameter("IVRSystem_019_ComputeDistortion", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_019_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_019_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_019_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_019_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_019_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_019_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_019_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_019_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetDXGIOutputInfo, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_019_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetDXGIOutputInfo((void *)1);
    check_ptr_parameter("IVRSystem_019_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_019_GetDXGIOutputInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetOutputDevice, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_019_GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetOutputDevice((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_019_GetOutputDevice", this_ptr_value);
    check_ptr_parameter("IVRSystem_019_GetOutputDevice", (void *)1);
    check_uint32_parameter("IVRSystem_019_GetOutputDevice", 2);
    check_ptr_parameter("IVRSystem_019_GetOutputDevice", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_019_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_019_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_019_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_019_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_019_SetDisplayVisibility", 1);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_019_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_019_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_019_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_019_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_019_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_019_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_019_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_019_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_019_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_019_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_019_ApplyTransform, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_019_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_ApplyTransform((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_019_ApplyTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_019_ApplyTransform", (void *)1);
    check_ptr_parameter("IVRSystem_019_ApplyTransform", (void *)2);
    check_ptr_parameter("IVRSystem_019_ApplyTransform", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_019_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetTrackedDeviceIndexForControllerRole(1);
    check_ptr_parameter("IVRSystem_019_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetTrackedDeviceIndexForControllerRole", 1);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
    ETrackedControllerRole (__stdcall *capi_IVRSystem_019_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetControllerRoleForTrackedDeviceIndex(1);
    check_ptr_parameter("IVRSystem_019_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetControllerRoleForTrackedDeviceIndex", 1);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetTrackedDeviceClass, 1, FALSE, FALSE);
    ETrackedDeviceClass (__stdcall *capi_IVRSystem_019_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_019_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_019_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_019_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_019_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_019_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_019_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_019_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_019_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_019_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_019_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_019_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_019_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_019_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_019_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_019_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_019_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_019_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_019_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_019_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_019_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_019_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_019_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_019_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetArrayTrackedDeviceProperty, 6, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_019_GetArrayTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetArrayTrackedDeviceProperty(1, 2, 3, (void *)4, 5, (void *)6);
    check_ptr_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", 2);
    check_uint32_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", 3);
    check_ptr_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", (void *)4);
    check_uint32_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", 5);
    check_ptr_parameter("IVRSystem_019_GetArrayTrackedDeviceProperty", (void *)6);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_019_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_019_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_019_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_019_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_019_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_019_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_019_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_019_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_019_PollNextEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_PollNextEvent((void *)1, 2);
    check_ptr_parameter("IVRSystem_019_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_019_PollNextEvent", (void *)1);
    check_uint32_parameter("IVRSystem_019_PollNextEvent", 2);

    init_thunk(t, this_ptr_value, IVRSystem_019_PollNextEventWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSystem_019_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_019_PollNextEventWithPose", (void *)2);
    check_uint32_parameter("IVRSystem_019_PollNextEventWithPose", 3);
    check_ptr_parameter("IVRSystem_019_PollNextEventWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_019_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_019_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetHiddenAreaMesh, 3, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_019_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetHiddenAreaMesh(data_ptr_value, 1, 2);
    check_ptr_parameter("IVRSystem_019_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_019_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetHiddenAreaMesh", 1);
    check_uint32_parameter("IVRSystem_019_GetHiddenAreaMesh", 2);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetControllerState, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetControllerState(1, (void *)2, 3);
    check_ptr_parameter("IVRSystem_019_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_019_GetControllerState", (void *)2);
    check_uint32_parameter("IVRSystem_019_GetControllerState", 3);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetControllerStateWithPose, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_019_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_019_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_019_GetControllerStateWithPose", (void *)3);
    check_uint32_parameter("IVRSystem_019_GetControllerStateWithPose", 4);
    check_ptr_parameter("IVRSystem_019_GetControllerStateWithPose", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_019_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_019_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_019_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_019_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_019_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_019_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_019_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_019_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_019_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_019_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_019_IsInputAvailable, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_IsInputAvailable)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_IsInputAvailable();
    check_ptr_parameter("IVRSystem_019_IsInputAvailable", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_019_IsSteamVRDrawingControllers, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_IsSteamVRDrawingControllers)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_IsSteamVRDrawingControllers();
    check_ptr_parameter("IVRSystem_019_IsSteamVRDrawingControllers", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_019_ShouldApplicationPause, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_ShouldApplicationPause)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_ShouldApplicationPause();
    check_ptr_parameter("IVRSystem_019_ShouldApplicationPause", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_019_ShouldApplicationReduceRenderingWork, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_019_ShouldApplicationReduceRenderingWork)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_ShouldApplicationReduceRenderingWork();
    check_ptr_parameter("IVRSystem_019_ShouldApplicationReduceRenderingWork", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_019_DriverDebugRequest, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_019_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_DriverDebugRequest(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRSystem_019_DriverDebugRequest", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_DriverDebugRequest", 1);
    check_ptr_parameter("IVRSystem_019_DriverDebugRequest", (void *)2);
    check_ptr_parameter("IVRSystem_019_DriverDebugRequest", (void *)3);
    check_uint32_parameter("IVRSystem_019_DriverDebugRequest", 4);

    init_thunk(t, this_ptr_value, IVRSystem_019_PerformFirmwareUpdate, 1, FALSE, FALSE);
    EVRFirmwareError (__stdcall *capi_IVRSystem_019_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_019_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_019_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_019_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_019_AcknowledgeQuit_Exiting)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_AcknowledgeQuit_Exiting();
    check_ptr_parameter("IVRSystem_019_AcknowledgeQuit_Exiting", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_019_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_019_AcknowledgeQuit_UserPrompt)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_019_AcknowledgeQuit_UserPrompt();
    check_ptr_parameter("IVRSystem_019_AcknowledgeQuit_UserPrompt", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRInput_006(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRInput_006_SetActionManifestPath, 1, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_SetActionManifestPath)(const char * pchActionManifestPath) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_SetActionManifestPath((void *)1);
    check_ptr_parameter("IVRInput_006_SetActionManifestPath", this_ptr_value);
    check_ptr_parameter("IVRInput_006_SetActionManifestPath", (void *)1);

    init_thunk(t, this_ptr_value, IVRInput_006_GetActionSetHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetActionSetHandle)(const char * pchActionSetName, VRActionSetHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetActionSetHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_006_GetActionSetHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_006_GetActionSetHandle", (void *)1);
    check_ptr_parameter("IVRInput_006_GetActionSetHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_006_GetActionHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetActionHandle)(const char * pchActionName, VRActionHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetActionHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_006_GetActionHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_006_GetActionHandle", (void *)1);
    check_ptr_parameter("IVRInput_006_GetActionHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_006_GetInputSourceHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetInputSourceHandle)(const char * pchInputSourcePath, VRInputValueHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetInputSourceHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_006_GetInputSourceHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_006_GetInputSourceHandle", (void *)1);
    check_ptr_parameter("IVRInput_006_GetInputSourceHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_006_UpdateActionState, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_UpdateActionState)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_UpdateActionState((void *)1, 2, 3);
    check_ptr_parameter("IVRInput_006_UpdateActionState", this_ptr_value);
    check_ptr_parameter("IVRInput_006_UpdateActionState", (void *)1);
    check_uint32_parameter("IVRInput_006_UpdateActionState", 2);
    check_uint32_parameter("IVRInput_006_UpdateActionState", 3);

    init_thunk(t, this_ptr_value, IVRInput_006_GetDigitalActionData, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetDigitalActionData)(VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetDigitalActionData(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_006_GetDigitalActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetDigitalActionData", 1);
    check_ptr_parameter("IVRInput_006_GetDigitalActionData", (void *)2);
    check_uint32_parameter("IVRInput_006_GetDigitalActionData", 3);
    check_uint64_parameter("IVRInput_006_GetDigitalActionData", 4);

    init_thunk(t, this_ptr_value, IVRInput_006_GetAnalogActionData, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetAnalogActionData)(VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetAnalogActionData(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_006_GetAnalogActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetAnalogActionData", 1);
    check_ptr_parameter("IVRInput_006_GetAnalogActionData", (void *)2);
    check_uint32_parameter("IVRInput_006_GetAnalogActionData", 3);
    check_uint64_parameter("IVRInput_006_GetAnalogActionData", 4);

    init_thunk(t, this_ptr_value, IVRInput_006_GetPoseActionDataRelativeToNow, 6, TRUE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetPoseActionDataRelativeToNow)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetPoseActionDataRelativeToNow(1, 2, 3.0f, (void *)4, 5, 6);
    check_ptr_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", 1);
    check_uint32_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", 2);
    check_float_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", 3.0f);
    check_ptr_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", (void *)4);
    check_uint32_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", 5);
    check_uint64_parameter("IVRInput_006_GetPoseActionDataRelativeToNow", 6);

    init_thunk(t, this_ptr_value, IVRInput_006_GetPoseActionDataForNextFrame, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetPoseActionDataForNextFrame)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetPoseActionDataForNextFrame(1, 2, (void *)3, 4, 5);
    check_ptr_parameter("IVRInput_006_GetPoseActionDataForNextFrame", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetPoseActionDataForNextFrame", 1);
    check_uint32_parameter("IVRInput_006_GetPoseActionDataForNextFrame", 2);
    check_ptr_parameter("IVRInput_006_GetPoseActionDataForNextFrame", (void *)3);
    check_uint32_parameter("IVRInput_006_GetPoseActionDataForNextFrame", 4);
    check_uint64_parameter("IVRInput_006_GetPoseActionDataForNextFrame", 5);

    init_thunk(t, this_ptr_value, IVRInput_006_GetSkeletalActionData, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetSkeletalActionData)(VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetSkeletalActionData(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_006_GetSkeletalActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetSkeletalActionData", 1);
    check_ptr_parameter("IVRInput_006_GetSkeletalActionData", (void *)2);
    check_uint32_parameter("IVRInput_006_GetSkeletalActionData", 3);

    init_thunk(t, this_ptr_value, IVRInput_006_GetBoneCount, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetBoneCount)(VRActionHandle_t action, uint32_t * pBoneCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetBoneCount(1, (void *)2);
    check_ptr_parameter("IVRInput_006_GetBoneCount", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetBoneCount", 1);
    check_ptr_parameter("IVRInput_006_GetBoneCount", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_006_GetBoneHierarchy, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetBoneHierarchy)(VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetBoneHierarchy(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_006_GetBoneHierarchy", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetBoneHierarchy", 1);
    check_ptr_parameter("IVRInput_006_GetBoneHierarchy", (void *)2);
    check_uint32_parameter("IVRInput_006_GetBoneHierarchy", 3);

    init_thunk(t, this_ptr_value, IVRInput_006_GetBoneName, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetBoneName)(VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetBoneName(1, 2, (void *)3, 4);
    check_ptr_parameter("IVRInput_006_GetBoneName", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetBoneName", 1);
    check_uint32_parameter("IVRInput_006_GetBoneName", 2);
    check_ptr_parameter("IVRInput_006_GetBoneName", (void *)3);
    check_uint32_parameter("IVRInput_006_GetBoneName", 4);

    init_thunk(t, this_ptr_value, IVRInput_006_GetSkeletalReferenceTransforms, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetSkeletalReferenceTransforms)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetSkeletalReferenceTransforms(1, 2, 3, (void *)4, 5);
    check_ptr_parameter("IVRInput_006_GetSkeletalReferenceTransforms", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetSkeletalReferenceTransforms", 1);
    check_uint32_parameter("IVRInput_006_GetSkeletalReferenceTransforms", 2);
    check_uint32_parameter("IVRInput_006_GetSkeletalReferenceTransforms", 3);
    check_ptr_parameter("IVRInput_006_GetSkeletalReferenceTransforms", (void *)4);
    check_uint32_parameter("IVRInput_006_GetSkeletalReferenceTransforms", 5);

    init_thunk(t, this_ptr_value, IVRInput_006_GetSkeletalTrackingLevel, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetSkeletalTrackingLevel)(VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetSkeletalTrackingLevel(1, (void *)2);
    check_ptr_parameter("IVRInput_006_GetSkeletalTrackingLevel", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetSkeletalTrackingLevel", 1);
    check_ptr_parameter("IVRInput_006_GetSkeletalTrackingLevel", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_006_GetSkeletalBoneData, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetSkeletalBoneData)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetSkeletalBoneData(1, 2, 3, (void *)4, 5);
    check_ptr_parameter("IVRInput_006_GetSkeletalBoneData", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetSkeletalBoneData", 1);
    check_uint32_parameter("IVRInput_006_GetSkeletalBoneData", 2);
    check_uint32_parameter("IVRInput_006_GetSkeletalBoneData", 3);
    check_ptr_parameter("IVRInput_006_GetSkeletalBoneData", (void *)4);
    check_uint32_parameter("IVRInput_006_GetSkeletalBoneData", 5);

    init_thunk(t, this_ptr_value, IVRInput_006_GetSkeletalSummaryData, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetSkeletalSummaryData)(VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetSkeletalSummaryData(1, 2, (void *)3);
    check_ptr_parameter("IVRInput_006_GetSkeletalSummaryData", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetSkeletalSummaryData", 1);
    check_uint32_parameter("IVRInput_006_GetSkeletalSummaryData", 2);
    check_ptr_parameter("IVRInput_006_GetSkeletalSummaryData", (void *)3);

    init_thunk(t, this_ptr_value, IVRInput_006_GetSkeletalBoneDataCompressed, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetSkeletalBoneDataCompressed)(VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetSkeletalBoneDataCompressed(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRInput_006_GetSkeletalBoneDataCompressed", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetSkeletalBoneDataCompressed", 1);
    check_uint32_parameter("IVRInput_006_GetSkeletalBoneDataCompressed", 2);
    check_ptr_parameter("IVRInput_006_GetSkeletalBoneDataCompressed", (void *)3);
    check_uint32_parameter("IVRInput_006_GetSkeletalBoneDataCompressed", 4);
    check_ptr_parameter("IVRInput_006_GetSkeletalBoneDataCompressed", (void *)5);

    init_thunk(t, this_ptr_value, IVRInput_006_DecompressSkeletalBoneData, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_DecompressSkeletalBoneData)(const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_DecompressSkeletalBoneData((void *)1, 2, 3, (void *)4, 5);
    check_ptr_parameter("IVRInput_006_DecompressSkeletalBoneData", this_ptr_value);
    check_ptr_parameter("IVRInput_006_DecompressSkeletalBoneData", (void *)1);
    check_uint32_parameter("IVRInput_006_DecompressSkeletalBoneData", 2);
    check_uint32_parameter("IVRInput_006_DecompressSkeletalBoneData", 3);
    check_ptr_parameter("IVRInput_006_DecompressSkeletalBoneData", (void *)4);
    check_uint32_parameter("IVRInput_006_DecompressSkeletalBoneData", 5);

    init_thunk(t, this_ptr_value, IVRInput_006_TriggerHapticVibrationAction, 6, TRUE, TRUE);
    EVRInputError (__stdcall *capi_IVRInput_006_TriggerHapticVibrationAction)(VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_TriggerHapticVibrationAction(1, 2.0f, 3.0f, 4.0f, 5.0f, 6);
    check_ptr_parameter("IVRInput_006_TriggerHapticVibrationAction", this_ptr_value);
    check_uint64_parameter("IVRInput_006_TriggerHapticVibrationAction", 1);
    check_float_parameter("IVRInput_006_TriggerHapticVibrationAction", 2.0f);
    check_float_parameter("IVRInput_006_TriggerHapticVibrationAction", 3.0f);
    check_float_parameter("IVRInput_006_TriggerHapticVibrationAction", 4.0f);
    check_float_parameter("IVRInput_006_TriggerHapticVibrationAction", 5.0f);
    check_uint64_parameter("IVRInput_006_TriggerHapticVibrationAction", 6);

    init_thunk(t, this_ptr_value, IVRInput_006_GetActionOrigins, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetActionOrigins(1, 2, (void *)3, 4);
    check_ptr_parameter("IVRInput_006_GetActionOrigins", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetActionOrigins", 1);
    check_uint64_parameter("IVRInput_006_GetActionOrigins", 2);
    check_ptr_parameter("IVRInput_006_GetActionOrigins", (void *)3);
    check_uint32_parameter("IVRInput_006_GetActionOrigins", 4);

    init_thunk(t, this_ptr_value, IVRInput_006_GetOriginLocalizedName, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetOriginLocalizedName)(VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetOriginLocalizedName(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_006_GetOriginLocalizedName", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetOriginLocalizedName", 1);
    check_ptr_parameter("IVRInput_006_GetOriginLocalizedName", (void *)2);
    check_uint32_parameter("IVRInput_006_GetOriginLocalizedName", 3);
    check_uint32_parameter("IVRInput_006_GetOriginLocalizedName", 4);

    init_thunk(t, this_ptr_value, IVRInput_006_GetOriginTrackedDeviceInfo, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_GetOriginTrackedDeviceInfo)(VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_GetOriginTrackedDeviceInfo(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_006_GetOriginTrackedDeviceInfo", this_ptr_value);
    check_uint64_parameter("IVRInput_006_GetOriginTrackedDeviceInfo", 1);
    check_ptr_parameter("IVRInput_006_GetOriginTrackedDeviceInfo", (void *)2);
    check_uint32_parameter("IVRInput_006_GetOriginTrackedDeviceInfo", 3);

    init_thunk(t, this_ptr_value, IVRInput_006_ShowActionOrigins, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_ShowActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_ShowActionOrigins(1, 2);
    check_ptr_parameter("IVRInput_006_ShowActionOrigins", this_ptr_value);
    check_uint64_parameter("IVRInput_006_ShowActionOrigins", 1);
    check_uint64_parameter("IVRInput_006_ShowActionOrigins", 2);

    init_thunk(t, this_ptr_value, IVRInput_006_ShowBindingsForActionSet, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_006_ShowBindingsForActionSet)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight) = (void *)t;

    clear_parameters();
    capi_IVRInput_006_ShowBindingsForActionSet((void *)1, 2, 3, 4);
    check_ptr_parameter("IVRInput_006_ShowBindingsForActionSet", this_ptr_value);
    check_ptr_parameter("IVRInput_006_ShowBindingsForActionSet", (void *)1);
    check_uint32_parameter("IVRInput_006_ShowBindingsForActionSet", 2);
    check_uint32_parameter("IVRInput_006_ShowBindingsForActionSet", 3);
    check_uint64_parameter("IVRInput_006_ShowBindingsForActionSet", 4);

    init_thunk(t, this_ptr_value, IVRInput_006_IsUsingLegacyInput, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRInput_006_IsUsingLegacyInput)() = (void *)t;

    clear_parameters();
    capi_IVRInput_006_IsUsingLegacyInput();
    check_ptr_parameter("IVRInput_006_IsUsingLegacyInput", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRInput_005(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRInput_005_SetActionManifestPath, 1, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_SetActionManifestPath)(const char * pchActionManifestPath) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_SetActionManifestPath((void *)1);
    check_ptr_parameter("IVRInput_005_SetActionManifestPath", this_ptr_value);
    check_ptr_parameter("IVRInput_005_SetActionManifestPath", (void *)1);

    init_thunk(t, this_ptr_value, IVRInput_005_GetActionSetHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetActionSetHandle)(const char * pchActionSetName, VRActionSetHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetActionSetHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_005_GetActionSetHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_005_GetActionSetHandle", (void *)1);
    check_ptr_parameter("IVRInput_005_GetActionSetHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_005_GetActionHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetActionHandle)(const char * pchActionName, VRActionHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetActionHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_005_GetActionHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_005_GetActionHandle", (void *)1);
    check_ptr_parameter("IVRInput_005_GetActionHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_005_GetInputSourceHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetInputSourceHandle)(const char * pchInputSourcePath, VRInputValueHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetInputSourceHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_005_GetInputSourceHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_005_GetInputSourceHandle", (void *)1);
    check_ptr_parameter("IVRInput_005_GetInputSourceHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_005_UpdateActionState, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_UpdateActionState)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_UpdateActionState((void *)1, 2, 3);
    check_ptr_parameter("IVRInput_005_UpdateActionState", this_ptr_value);
    check_ptr_parameter("IVRInput_005_UpdateActionState", (void *)1);
    check_uint32_parameter("IVRInput_005_UpdateActionState", 2);
    check_uint32_parameter("IVRInput_005_UpdateActionState", 3);

    init_thunk(t, this_ptr_value, IVRInput_005_GetDigitalActionData, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetDigitalActionData)(VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetDigitalActionData(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_005_GetDigitalActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetDigitalActionData", 1);
    check_ptr_parameter("IVRInput_005_GetDigitalActionData", (void *)2);
    check_uint32_parameter("IVRInput_005_GetDigitalActionData", 3);
    check_uint64_parameter("IVRInput_005_GetDigitalActionData", 4);

    init_thunk(t, this_ptr_value, IVRInput_005_GetAnalogActionData, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetAnalogActionData)(VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetAnalogActionData(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_005_GetAnalogActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetAnalogActionData", 1);
    check_ptr_parameter("IVRInput_005_GetAnalogActionData", (void *)2);
    check_uint32_parameter("IVRInput_005_GetAnalogActionData", 3);
    check_uint64_parameter("IVRInput_005_GetAnalogActionData", 4);

    init_thunk(t, this_ptr_value, IVRInput_005_GetPoseActionData, 6, TRUE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetPoseActionData)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetPoseActionData(1, 2, 3.0f, (void *)4, 5, 6);
    check_ptr_parameter("IVRInput_005_GetPoseActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetPoseActionData", 1);
    check_uint32_parameter("IVRInput_005_GetPoseActionData", 2);
    check_float_parameter("IVRInput_005_GetPoseActionData", 3.0f);
    check_ptr_parameter("IVRInput_005_GetPoseActionData", (void *)4);
    check_uint32_parameter("IVRInput_005_GetPoseActionData", 5);
    check_uint64_parameter("IVRInput_005_GetPoseActionData", 6);

    init_thunk(t, this_ptr_value, IVRInput_005_GetSkeletalActionData, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetSkeletalActionData)(VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetSkeletalActionData(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_005_GetSkeletalActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetSkeletalActionData", 1);
    check_ptr_parameter("IVRInput_005_GetSkeletalActionData", (void *)2);
    check_uint32_parameter("IVRInput_005_GetSkeletalActionData", 3);

    init_thunk(t, this_ptr_value, IVRInput_005_GetBoneCount, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetBoneCount)(VRActionHandle_t action, uint32_t * pBoneCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetBoneCount(1, (void *)2);
    check_ptr_parameter("IVRInput_005_GetBoneCount", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetBoneCount", 1);
    check_ptr_parameter("IVRInput_005_GetBoneCount", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_005_GetBoneHierarchy, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetBoneHierarchy)(VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetBoneHierarchy(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_005_GetBoneHierarchy", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetBoneHierarchy", 1);
    check_ptr_parameter("IVRInput_005_GetBoneHierarchy", (void *)2);
    check_uint32_parameter("IVRInput_005_GetBoneHierarchy", 3);

    init_thunk(t, this_ptr_value, IVRInput_005_GetBoneName, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetBoneName)(VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetBoneName(1, 2, (void *)3, 4);
    check_ptr_parameter("IVRInput_005_GetBoneName", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetBoneName", 1);
    check_uint32_parameter("IVRInput_005_GetBoneName", 2);
    check_ptr_parameter("IVRInput_005_GetBoneName", (void *)3);
    check_uint32_parameter("IVRInput_005_GetBoneName", 4);

    init_thunk(t, this_ptr_value, IVRInput_005_GetSkeletalReferenceTransforms, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetSkeletalReferenceTransforms)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetSkeletalReferenceTransforms(1, 2, 3, (void *)4, 5);
    check_ptr_parameter("IVRInput_005_GetSkeletalReferenceTransforms", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetSkeletalReferenceTransforms", 1);
    check_uint32_parameter("IVRInput_005_GetSkeletalReferenceTransforms", 2);
    check_uint32_parameter("IVRInput_005_GetSkeletalReferenceTransforms", 3);
    check_ptr_parameter("IVRInput_005_GetSkeletalReferenceTransforms", (void *)4);
    check_uint32_parameter("IVRInput_005_GetSkeletalReferenceTransforms", 5);

    init_thunk(t, this_ptr_value, IVRInput_005_GetSkeletalTrackingLevel, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetSkeletalTrackingLevel)(VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetSkeletalTrackingLevel(1, (void *)2);
    check_ptr_parameter("IVRInput_005_GetSkeletalTrackingLevel", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetSkeletalTrackingLevel", 1);
    check_ptr_parameter("IVRInput_005_GetSkeletalTrackingLevel", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_005_GetSkeletalBoneData, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetSkeletalBoneData)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetSkeletalBoneData(1, 2, 3, (void *)4, 5);
    check_ptr_parameter("IVRInput_005_GetSkeletalBoneData", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetSkeletalBoneData", 1);
    check_uint32_parameter("IVRInput_005_GetSkeletalBoneData", 2);
    check_uint32_parameter("IVRInput_005_GetSkeletalBoneData", 3);
    check_ptr_parameter("IVRInput_005_GetSkeletalBoneData", (void *)4);
    check_uint32_parameter("IVRInput_005_GetSkeletalBoneData", 5);

    init_thunk(t, this_ptr_value, IVRInput_005_GetSkeletalSummaryData, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetSkeletalSummaryData)(VRActionHandle_t action, VRSkeletalSummaryData_t * pSkeletalSummaryData) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetSkeletalSummaryData(1, (void *)2);
    check_ptr_parameter("IVRInput_005_GetSkeletalSummaryData", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetSkeletalSummaryData", 1);
    check_ptr_parameter("IVRInput_005_GetSkeletalSummaryData", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_005_GetSkeletalBoneDataCompressed, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetSkeletalBoneDataCompressed)(VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetSkeletalBoneDataCompressed(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRInput_005_GetSkeletalBoneDataCompressed", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetSkeletalBoneDataCompressed", 1);
    check_uint32_parameter("IVRInput_005_GetSkeletalBoneDataCompressed", 2);
    check_ptr_parameter("IVRInput_005_GetSkeletalBoneDataCompressed", (void *)3);
    check_uint32_parameter("IVRInput_005_GetSkeletalBoneDataCompressed", 4);
    check_ptr_parameter("IVRInput_005_GetSkeletalBoneDataCompressed", (void *)5);

    init_thunk(t, this_ptr_value, IVRInput_005_DecompressSkeletalBoneData, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_DecompressSkeletalBoneData)(const void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_DecompressSkeletalBoneData((void *)1, 2, 3, (void *)4, 5);
    check_ptr_parameter("IVRInput_005_DecompressSkeletalBoneData", this_ptr_value);
    check_ptr_parameter("IVRInput_005_DecompressSkeletalBoneData", (void *)1);
    check_uint32_parameter("IVRInput_005_DecompressSkeletalBoneData", 2);
    check_uint32_parameter("IVRInput_005_DecompressSkeletalBoneData", 3);
    check_ptr_parameter("IVRInput_005_DecompressSkeletalBoneData", (void *)4);
    check_uint32_parameter("IVRInput_005_DecompressSkeletalBoneData", 5);

    init_thunk(t, this_ptr_value, IVRInput_005_TriggerHapticVibrationAction, 6, TRUE, TRUE);
    EVRInputError (__stdcall *capi_IVRInput_005_TriggerHapticVibrationAction)(VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_TriggerHapticVibrationAction(1, 2.0f, 3.0f, 4.0f, 5.0f, 6);
    check_ptr_parameter("IVRInput_005_TriggerHapticVibrationAction", this_ptr_value);
    check_uint64_parameter("IVRInput_005_TriggerHapticVibrationAction", 1);
    check_float_parameter("IVRInput_005_TriggerHapticVibrationAction", 2.0f);
    check_float_parameter("IVRInput_005_TriggerHapticVibrationAction", 3.0f);
    check_float_parameter("IVRInput_005_TriggerHapticVibrationAction", 4.0f);
    check_float_parameter("IVRInput_005_TriggerHapticVibrationAction", 5.0f);
    check_uint64_parameter("IVRInput_005_TriggerHapticVibrationAction", 6);

    init_thunk(t, this_ptr_value, IVRInput_005_GetActionOrigins, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetActionOrigins(1, 2, (void *)3, 4);
    check_ptr_parameter("IVRInput_005_GetActionOrigins", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetActionOrigins", 1);
    check_uint64_parameter("IVRInput_005_GetActionOrigins", 2);
    check_ptr_parameter("IVRInput_005_GetActionOrigins", (void *)3);
    check_uint32_parameter("IVRInput_005_GetActionOrigins", 4);

    init_thunk(t, this_ptr_value, IVRInput_005_GetOriginLocalizedName, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetOriginLocalizedName)(VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetOriginLocalizedName(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_005_GetOriginLocalizedName", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetOriginLocalizedName", 1);
    check_ptr_parameter("IVRInput_005_GetOriginLocalizedName", (void *)2);
    check_uint32_parameter("IVRInput_005_GetOriginLocalizedName", 3);
    check_uint32_parameter("IVRInput_005_GetOriginLocalizedName", 4);

    init_thunk(t, this_ptr_value, IVRInput_005_GetOriginTrackedDeviceInfo, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_GetOriginTrackedDeviceInfo)(VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_GetOriginTrackedDeviceInfo(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_005_GetOriginTrackedDeviceInfo", this_ptr_value);
    check_uint64_parameter("IVRInput_005_GetOriginTrackedDeviceInfo", 1);
    check_ptr_parameter("IVRInput_005_GetOriginTrackedDeviceInfo", (void *)2);
    check_uint32_parameter("IVRInput_005_GetOriginTrackedDeviceInfo", 3);

    init_thunk(t, this_ptr_value, IVRInput_005_ShowActionOrigins, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_ShowActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_ShowActionOrigins(1, 2);
    check_ptr_parameter("IVRInput_005_ShowActionOrigins", this_ptr_value);
    check_uint64_parameter("IVRInput_005_ShowActionOrigins", 1);
    check_uint64_parameter("IVRInput_005_ShowActionOrigins", 2);

    init_thunk(t, this_ptr_value, IVRInput_005_ShowBindingsForActionSet, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_005_ShowBindingsForActionSet)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight) = (void *)t;

    clear_parameters();
    capi_IVRInput_005_ShowBindingsForActionSet((void *)1, 2, 3, 4);
    check_ptr_parameter("IVRInput_005_ShowBindingsForActionSet", this_ptr_value);
    check_ptr_parameter("IVRInput_005_ShowBindingsForActionSet", (void *)1);
    check_uint32_parameter("IVRInput_005_ShowBindingsForActionSet", 2);
    check_uint32_parameter("IVRInput_005_ShowBindingsForActionSet", 3);
    check_uint64_parameter("IVRInput_005_ShowBindingsForActionSet", 4);

    init_thunk(t, this_ptr_value, IVRInput_005_IsUsingLegacyInput, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRInput_005_IsUsingLegacyInput)() = (void *)t;

    clear_parameters();
    capi_IVRInput_005_IsUsingLegacyInput();
    check_ptr_parameter("IVRInput_005_IsUsingLegacyInput", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRIOBuffer_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Open, 5, FALSE, FALSE);
    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Open)(const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer) = (void *)t;

    clear_parameters();
    capi_IVRIOBuffer_001_Open((void *)1, 2, 3, 4, (void *)5);
    check_ptr_parameter("IVRIOBuffer_001_Open", this_ptr_value);
    check_ptr_parameter("IVRIOBuffer_001_Open", (void *)1);
    check_uint32_parameter("IVRIOBuffer_001_Open", 2);
    check_uint32_parameter("IVRIOBuffer_001_Open", 3);
    check_uint32_parameter("IVRIOBuffer_001_Open", 4);
    check_ptr_parameter("IVRIOBuffer_001_Open", (void *)5);

    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Close, 1, FALSE, FALSE);
    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Close)(IOBufferHandle_t ulBuffer) = (void *)t;

    clear_parameters();
    capi_IVRIOBuffer_001_Close(1);
    check_ptr_parameter("IVRIOBuffer_001_Close", this_ptr_value);
    check_uint64_parameter("IVRIOBuffer_001_Close", 1);

    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Read, 4, FALSE, FALSE);
    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Read)(IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead) = (void *)t;

    clear_parameters();
    capi_IVRIOBuffer_001_Read(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRIOBuffer_001_Read", this_ptr_value);
    check_uint64_parameter("IVRIOBuffer_001_Read", 1);
    check_ptr_parameter("IVRIOBuffer_001_Read", (void *)2);
    check_uint32_parameter("IVRIOBuffer_001_Read", 3);
    check_ptr_parameter("IVRIOBuffer_001_Read", (void *)4);

    init_thunk(t, this_ptr_value, IVRIOBuffer_001_Write, 3, FALSE, FALSE);
    EIOBufferError (__stdcall *capi_IVRIOBuffer_001_Write)(IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes) = (void *)t;

    clear_parameters();
    capi_IVRIOBuffer_001_Write(1, (void *)2, 3);
    check_ptr_parameter("IVRIOBuffer_001_Write", this_ptr_value);
    check_uint64_parameter("IVRIOBuffer_001_Write", 1);
    check_ptr_parameter("IVRIOBuffer_001_Write", (void *)2);
    check_uint32_parameter("IVRIOBuffer_001_Write", 3);

    init_thunk(t, this_ptr_value, IVRIOBuffer_001_PropertyContainer, 1, FALSE, FALSE);
    PropertyContainerHandle_t (__stdcall *capi_IVRIOBuffer_001_PropertyContainer)(IOBufferHandle_t ulBuffer) = (void *)t;

    clear_parameters();
    capi_IVRIOBuffer_001_PropertyContainer(1);
    check_ptr_parameter("IVRIOBuffer_001_PropertyContainer", this_ptr_value);
    check_uint64_parameter("IVRIOBuffer_001_PropertyContainer", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRChaperoneSetup_005(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_CommitWorkingCopy, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_CommitWorkingCopy)(EChaperoneConfigFile configFile) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_CommitWorkingCopy(1);
    check_ptr_parameter("IVRChaperoneSetup_005_CommitWorkingCopy", this_ptr_value);
    check_uint32_parameter("IVRChaperoneSetup_005_CommitWorkingCopy", 1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_RevertWorkingCopy, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_005_RevertWorkingCopy)() = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_RevertWorkingCopy();
    check_ptr_parameter("IVRChaperoneSetup_005_RevertWorkingCopy", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetWorkingPlayAreaSize, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_GetWorkingPlayAreaSize)(float * pSizeX, float * pSizeZ) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_GetWorkingPlayAreaSize((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingPlayAreaSize", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingPlayAreaSize", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingPlayAreaSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetWorkingPlayAreaRect, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_GetWorkingPlayAreaRect)(HmdQuad_t * rect) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_GetWorkingPlayAreaRect((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingPlayAreaRect", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingPlayAreaRect", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingCollisionBoundsInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveCollisionBoundsInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingSeatedZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatStandingZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_GetWorkingStandingZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_SetWorkingPlayAreaSize, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_005_SetWorkingPlayAreaSize)(float sizeX, float sizeZ) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_SetWorkingPlayAreaSize(1.0f, 2.0f);
    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingPlayAreaSize", this_ptr_value);
    check_float_parameter("IVRChaperoneSetup_005_SetWorkingPlayAreaSize", 1.0f);
    check_float_parameter("IVRChaperoneSetup_005_SetWorkingPlayAreaSize", 2.0f);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo((void *)1, 2);
    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo", (void *)1);
    check_uint32_parameter("IVRChaperoneSetup_005_SetWorkingCollisionBoundsInfo", 2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pMatSeatedZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingSeatedZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose)(HmdMatrix34_t * pMatStandingZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingStandingZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_ReloadFromDisk, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_005_ReloadFromDisk)(EChaperoneConfigFile configFile) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_ReloadFromDisk(1);
    check_ptr_parameter("IVRChaperoneSetup_005_ReloadFromDisk", this_ptr_value);
    check_uint32_parameter("IVRChaperoneSetup_005_ReloadFromDisk", 1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveSeatedZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo)(uint8_t * pTagsBuffer, uint32_t unTagCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo((void *)1, 2);
    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo", (void *)1);
    check_uint32_parameter("IVRChaperoneSetup_005_SetWorkingCollisionBoundsTagsInfo", 2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo)(uint8_t * pTagsBuffer, uint32_t * punTagCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_005_GetLiveCollisionBoundsTagsInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo((void *)1, 2);
    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo", (void *)1);
    check_uint32_parameter("IVRChaperoneSetup_005_SetWorkingPhysicalBoundsInfo", 2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_005_GetLivePhysicalBoundsInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_ExportLiveToBuffer, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_ExportLiveToBuffer)(char * pBuffer, uint32_t * pnBufferLength) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_ExportLiveToBuffer((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_005_ExportLiveToBuffer", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_ExportLiveToBuffer", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_005_ExportLiveToBuffer", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_005_ImportFromBufferToWorking, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_005_ImportFromBufferToWorking)(const char * pBuffer, uint32_t nImportFlags) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_005_ImportFromBufferToWorking((void *)1, 2);
    check_ptr_parameter("IVRChaperoneSetup_005_ImportFromBufferToWorking", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_005_ImportFromBufferToWorking", (void *)1);
    check_uint32_parameter("IVRChaperoneSetup_005_ImportFromBufferToWorking", 2);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_018(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_018_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_018_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_018_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_018_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_018_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_018_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_018_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_018_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_018_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetHighQualityOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_018_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_018_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_018_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_018_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_018_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_018_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_018_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_018_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_018_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_018_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_018_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayName, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayName(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_SetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayName", 1);
    check_ptr_parameter("IVROverlay_018_SetOverlayName", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_018_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_018_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_018_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_018_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_018_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_018_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_018_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_018_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_018_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_018_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_018_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_018_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_018_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_018_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_018_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_018_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_018_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_018_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_018_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_018_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_018_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_018_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_018_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_018_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_018_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTexelAspect, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayTexelAspect(1, 2.0f);
    check_ptr_parameter("IVROverlay_018_SetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayTexelAspect", 1);
    check_float_parameter("IVROverlay_018_SetOverlayTexelAspect", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTexelAspect, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayTexelAspect(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayTexelAspect", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayTexelAspect", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlaySortOrder(1, 2);
    check_ptr_parameter("IVROverlay_018_SetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlaySortOrder", 1);
    check_uint32_parameter("IVROverlay_018_SetOverlaySortOrder", 2);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlaySortOrder(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlaySortOrder", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlaySortOrder", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_018_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_018_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_018_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_018_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_018_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayRenderModel, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_018_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_018_GetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayRenderModel", (void *)2);
    check_uint32_parameter("IVROverlay_018_GetOverlayRenderModel", 3);
    check_ptr_parameter("IVROverlay_018_GetOverlayRenderModel", (void *)4);
    check_ptr_parameter("IVROverlay_018_GetOverlayRenderModel", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayRenderModel, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayRenderModel(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_018_SetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_018_SetOverlayRenderModel", (void *)2);
    check_ptr_parameter("IVROverlay_018_SetOverlayRenderModel", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_018_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_018_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_018_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_018_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_018_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayTransformOverlayRelative", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformOverlayRelative", (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_018_SetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayTransformOverlayRelative", 1);
    check_uint64_parameter("IVROverlay_018_SetOverlayTransformOverlayRelative", 2);
    check_ptr_parameter("IVROverlay_018_SetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_018_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_018_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_HideOverlay(1);
    check_ptr_parameter("IVROverlay_018_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_018_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_018_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_018_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_018_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_018_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_018_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_018_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_018_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_018_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_018_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_018_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_018_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_018_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_018_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_018_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_018_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_018_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_018_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_018_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_018_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_018_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetGamepadFocusOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_018_GetGamepadFocusOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetGamepadFocusOverlay();
    check_ptr_parameter("IVROverlay_018_GetGamepadFocusOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetGamepadFocusOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetGamepadFocusOverlay(1);
    check_ptr_parameter("IVROverlay_018_SetGamepadFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetGamepadFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayNeighbor, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayNeighbor(1, 2, 3);
    check_ptr_parameter("IVROverlay_018_SetOverlayNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_018_SetOverlayNeighbor", 1);
    check_uint64_parameter("IVROverlay_018_SetOverlayNeighbor", 2);
    check_uint64_parameter("IVROverlay_018_SetOverlayNeighbor", 3);

    init_thunk(t, this_ptr_value, IVROverlay_018_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_MoveGamepadFocusToNeighbor(1, 2);
    check_ptr_parameter("IVROverlay_018_MoveGamepadFocusToNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_018_MoveGamepadFocusToNeighbor", 1);
    check_uint64_parameter("IVROverlay_018_MoveGamepadFocusToNeighbor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayDualAnalogTransform, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * vCenter, float fRadius) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayDualAnalogTransform(1, 2, (void *)3, 4.0f);
    check_ptr_parameter("IVROverlay_018_SetOverlayDualAnalogTransform", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayDualAnalogTransform", 1);
    check_uint32_parameter("IVROverlay_018_SetOverlayDualAnalogTransform", 2);
    check_ptr_parameter("IVROverlay_018_SetOverlayDualAnalogTransform", (void *)3);
    check_float_parameter("IVROverlay_018_SetOverlayDualAnalogTransform", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayDualAnalogTransform, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayDualAnalogTransform(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_018_GetOverlayDualAnalogTransform", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayDualAnalogTransform", 1);
    check_uint32_parameter("IVROverlay_018_GetOverlayDualAnalogTransform", 2);
    check_ptr_parameter("IVROverlay_018_GetOverlayDualAnalogTransform", (void *)3);
    check_ptr_parameter("IVROverlay_018_GetOverlayDualAnalogTransform", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_018_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_018_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_018_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_018_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_018_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_018_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_018_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_018_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTexture, 9, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)8);
    check_ptr_parameter("IVROverlay_018_GetOverlayTexture", (void *)9);

    init_thunk(t, this_ptr_value, IVROverlay_018_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_018_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayTextureSize, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayTextureSize(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_018_GetOverlayTextureSize", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayTextureSize", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayTextureSize", (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayTextureSize", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_018_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_018_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_018_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_018_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_018_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_018_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_018_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_018_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_018_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_018_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_018_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_018_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_018_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_018_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_018_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_018_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_018_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_018_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_018_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_018_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_018_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_018_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_018_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_018_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_018_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_018_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_018_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_018_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_018_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_018_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_018_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_018_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_018_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_018_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_018_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_018_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_018_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_018_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_018_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_018_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_018_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_018_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_018_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_018_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_HideKeyboard();
    check_ptr_parameter("IVROverlay_018_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_018_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_018_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_018_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_018_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_018_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_018_SetKeyboardPositionForOverlay", DEFAULT_RECT);

    init_thunk(t, this_ptr_value, IVROverlay_018_SetOverlayIntersectionMask, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
    check_ptr_parameter("IVROverlay_018_SetOverlayIntersectionMask", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_SetOverlayIntersectionMask", 1);
    check_ptr_parameter("IVROverlay_018_SetOverlayIntersectionMask", (void *)2);
    check_uint32_parameter("IVROverlay_018_SetOverlayIntersectionMask", 3);
    check_uint32_parameter("IVROverlay_018_SetOverlayIntersectionMask", 4);

    init_thunk(t, this_ptr_value, IVROverlay_018_GetOverlayFlags, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_018_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_GetOverlayFlags(1, (void *)2);
    check_ptr_parameter("IVROverlay_018_GetOverlayFlags", this_ptr_value);
    check_uint64_parameter("IVROverlay_018_GetOverlayFlags", 1);
    check_ptr_parameter("IVROverlay_018_GetOverlayFlags", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_018_ShowMessageOverlay, 6, FALSE, FALSE);
    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_018_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", (void *)4);
    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", (void *)5);
    check_ptr_parameter("IVROverlay_018_ShowMessageOverlay", (void *)6);

    init_thunk(t, this_ptr_value, IVROverlay_018_CloseMessageOverlay, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_018_CloseMessageOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_018_CloseMessageOverlay();
    check_ptr_parameter("IVROverlay_018_CloseMessageOverlay", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRTrackedCamera_004(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_004_GetCameraErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRTrackedCamera_004_GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_004_GetCameraErrorNameFromEnum(1);
    check_ptr_parameter("IVRTrackedCamera_004_GetCameraErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_004_GetCameraErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_004_HasCamera, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_004_HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_004_HasCamera(1, (void *)2);
    check_ptr_parameter("IVRTrackedCamera_004_HasCamera", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_004_HasCamera", 1);
    check_ptr_parameter("IVRTrackedCamera_004_HasCamera", (void *)2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_004_GetCameraFrameSize, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_004_GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_004_GetCameraFrameSize(1, 2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_004_GetCameraFrameSize", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_004_GetCameraFrameSize", 1);
    check_uint32_parameter("IVRTrackedCamera_004_GetCameraFrameSize", 2);
    check_ptr_parameter("IVRTrackedCamera_004_GetCameraFrameSize", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_004_GetCameraFrameSize", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_004_GetCameraFrameSize", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_004_GetCameraIntrinsics, 4, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_004_GetCameraIntrinsics)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_004_GetCameraIntrinsics(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRTrackedCamera_004_GetCameraIntrinsics", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_004_GetCameraIntrinsics", 1);
    check_uint32_parameter("IVRTrackedCamera_004_GetCameraIntrinsics", 2);
    check_ptr_parameter("IVRTrackedCamera_004_GetCameraIntrinsics", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_004_GetCameraIntrinsics", (void *)4);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_004_GetCameraProjection, 5, TRUE, TRUE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_004_GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_004_GetCameraProjection(1, 2, 3.0f, 4.0f, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_004_GetCameraProjection", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_004_GetCameraProjection", 1);
    check_uint32_parameter("IVRTrackedCamera_004_GetCameraProjection", 2);
    check_float_parameter("IVRTrackedCamera_004_GetCameraProjection", 3.0f);
    check_float_parameter("IVRTrackedCamera_004_GetCameraProjection", 4.0f);
    check_ptr_parameter("IVRTrackedCamera_004_GetCameraProjection", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_004_AcquireVideoStreamingService, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_004_AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_004_AcquireVideoStreamingService(1, (void *)2);
    check_ptr_parameter("IVRTrackedCamera_004_AcquireVideoStreamingService", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_004_AcquireVideoStreamingService", 1);
    check_ptr_parameter("IVRTrackedCamera_004_AcquireVideoStreamingService", (void *)2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_004_ReleaseVideoStreamingService, 1, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_004_ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_004_ReleaseVideoStreamingService(1);
    check_ptr_parameter("IVRTrackedCamera_004_ReleaseVideoStreamingService", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_004_ReleaseVideoStreamingService", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_004_GetVideoStreamFrameBuffer, 6, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_004_GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(1, 2, (void *)3, 4, (void *)5, 6);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamFrameBuffer", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_004_GetVideoStreamFrameBuffer", 1);
    check_uint32_parameter("IVRTrackedCamera_004_GetVideoStreamFrameBuffer", 2);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamFrameBuffer", (void *)3);
    check_uint32_parameter("IVRTrackedCamera_004_GetVideoStreamFrameBuffer", 4);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamFrameBuffer", (void *)5);
    check_uint32_parameter("IVRTrackedCamera_004_GetVideoStreamFrameBuffer", 6);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_004_GetVideoStreamTextureSize, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_004_GetVideoStreamTextureSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_004_GetVideoStreamTextureSize(1, 2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamTextureSize", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_004_GetVideoStreamTextureSize", 1);
    check_uint32_parameter("IVRTrackedCamera_004_GetVideoStreamTextureSize", 2);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamTextureSize", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamTextureSize", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamTextureSize", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_004_GetVideoStreamTextureD3D11, 6, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_004_GetVideoStreamTextureD3D11)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(1, 2, (void *)3, (void *)4, (void *)5, 6);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamTextureD3D11", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_004_GetVideoStreamTextureD3D11", 1);
    check_uint32_parameter("IVRTrackedCamera_004_GetVideoStreamTextureD3D11", 2);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamTextureD3D11", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamTextureD3D11", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamTextureD3D11", (void *)5);
    check_uint32_parameter("IVRTrackedCamera_004_GetVideoStreamTextureD3D11", 6);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_004_GetVideoStreamTextureGL, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_004_GetVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_004_GetVideoStreamTextureGL(1, 2, (void *)3, (void *)4, 5);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamTextureGL", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_004_GetVideoStreamTextureGL", 1);
    check_uint32_parameter("IVRTrackedCamera_004_GetVideoStreamTextureGL", 2);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamTextureGL", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_004_GetVideoStreamTextureGL", (void *)4);
    check_uint32_parameter("IVRTrackedCamera_004_GetVideoStreamTextureGL", 5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_004_ReleaseVideoStreamTextureGL, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_004_ReleaseVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_004_ReleaseVideoStreamTextureGL(1, 2);
    check_ptr_parameter("IVRTrackedCamera_004_ReleaseVideoStreamTextureGL", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_004_ReleaseVideoStreamTextureGL", 1);
    check_uint32_parameter("IVRTrackedCamera_004_ReleaseVideoStreamTextureGL", 2);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRInput_004(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRInput_004_SetActionManifestPath, 1, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_SetActionManifestPath)(const char * pchActionManifestPath) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_SetActionManifestPath((void *)1);
    check_ptr_parameter("IVRInput_004_SetActionManifestPath", this_ptr_value);
    check_ptr_parameter("IVRInput_004_SetActionManifestPath", (void *)1);

    init_thunk(t, this_ptr_value, IVRInput_004_GetActionSetHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_GetActionSetHandle)(const char * pchActionSetName, VRActionSetHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_GetActionSetHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_004_GetActionSetHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_004_GetActionSetHandle", (void *)1);
    check_ptr_parameter("IVRInput_004_GetActionSetHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_004_GetActionHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_GetActionHandle)(const char * pchActionName, VRActionHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_GetActionHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_004_GetActionHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_004_GetActionHandle", (void *)1);
    check_ptr_parameter("IVRInput_004_GetActionHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_004_GetInputSourceHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_GetInputSourceHandle)(const char * pchInputSourcePath, VRInputValueHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_GetInputSourceHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_004_GetInputSourceHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_004_GetInputSourceHandle", (void *)1);
    check_ptr_parameter("IVRInput_004_GetInputSourceHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_004_UpdateActionState, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_UpdateActionState)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_UpdateActionState((void *)1, 2, 3);
    check_ptr_parameter("IVRInput_004_UpdateActionState", this_ptr_value);
    check_ptr_parameter("IVRInput_004_UpdateActionState", (void *)1);
    check_uint32_parameter("IVRInput_004_UpdateActionState", 2);
    check_uint32_parameter("IVRInput_004_UpdateActionState", 3);

    init_thunk(t, this_ptr_value, IVRInput_004_GetDigitalActionData, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_GetDigitalActionData)(VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_GetDigitalActionData(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_004_GetDigitalActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_004_GetDigitalActionData", 1);
    check_ptr_parameter("IVRInput_004_GetDigitalActionData", (void *)2);
    check_uint32_parameter("IVRInput_004_GetDigitalActionData", 3);
    check_uint64_parameter("IVRInput_004_GetDigitalActionData", 4);

    init_thunk(t, this_ptr_value, IVRInput_004_GetAnalogActionData, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_GetAnalogActionData)(VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_GetAnalogActionData(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_004_GetAnalogActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_004_GetAnalogActionData", 1);
    check_ptr_parameter("IVRInput_004_GetAnalogActionData", (void *)2);
    check_uint32_parameter("IVRInput_004_GetAnalogActionData", 3);
    check_uint64_parameter("IVRInput_004_GetAnalogActionData", 4);

    init_thunk(t, this_ptr_value, IVRInput_004_GetPoseActionData, 6, TRUE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_GetPoseActionData)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_GetPoseActionData(1, 2, 3.0f, (void *)4, 5, 6);
    check_ptr_parameter("IVRInput_004_GetPoseActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_004_GetPoseActionData", 1);
    check_uint32_parameter("IVRInput_004_GetPoseActionData", 2);
    check_float_parameter("IVRInput_004_GetPoseActionData", 3.0f);
    check_ptr_parameter("IVRInput_004_GetPoseActionData", (void *)4);
    check_uint32_parameter("IVRInput_004_GetPoseActionData", 5);
    check_uint64_parameter("IVRInput_004_GetPoseActionData", 6);

    init_thunk(t, this_ptr_value, IVRInput_004_GetSkeletalActionData, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_GetSkeletalActionData)(VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_GetSkeletalActionData(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRInput_004_GetSkeletalActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_004_GetSkeletalActionData", 1);
    check_ptr_parameter("IVRInput_004_GetSkeletalActionData", (void *)2);
    check_uint32_parameter("IVRInput_004_GetSkeletalActionData", 3);
    check_uint64_parameter("IVRInput_004_GetSkeletalActionData", 4);

    init_thunk(t, this_ptr_value, IVRInput_004_GetSkeletalBoneData, 6, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_GetSkeletalBoneData)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_GetSkeletalBoneData(1, 2, 3, (void *)4, 5, 6);
    check_ptr_parameter("IVRInput_004_GetSkeletalBoneData", this_ptr_value);
    check_uint64_parameter("IVRInput_004_GetSkeletalBoneData", 1);
    check_uint32_parameter("IVRInput_004_GetSkeletalBoneData", 2);
    check_uint32_parameter("IVRInput_004_GetSkeletalBoneData", 3);
    check_ptr_parameter("IVRInput_004_GetSkeletalBoneData", (void *)4);
    check_uint32_parameter("IVRInput_004_GetSkeletalBoneData", 5);
    check_uint64_parameter("IVRInput_004_GetSkeletalBoneData", 6);

    init_thunk(t, this_ptr_value, IVRInput_004_GetSkeletalBoneDataCompressed, 7, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_GetSkeletalBoneDataCompressed)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_GetSkeletalBoneDataCompressed(1, 2, 3, (void *)4, 5, (void *)6, 7);
    check_ptr_parameter("IVRInput_004_GetSkeletalBoneDataCompressed", this_ptr_value);
    check_uint64_parameter("IVRInput_004_GetSkeletalBoneDataCompressed", 1);
    check_uint32_parameter("IVRInput_004_GetSkeletalBoneDataCompressed", 2);
    check_uint32_parameter("IVRInput_004_GetSkeletalBoneDataCompressed", 3);
    check_ptr_parameter("IVRInput_004_GetSkeletalBoneDataCompressed", (void *)4);
    check_uint32_parameter("IVRInput_004_GetSkeletalBoneDataCompressed", 5);
    check_ptr_parameter("IVRInput_004_GetSkeletalBoneDataCompressed", (void *)6);
    check_uint64_parameter("IVRInput_004_GetSkeletalBoneDataCompressed", 7);

    init_thunk(t, this_ptr_value, IVRInput_004_DecompressSkeletalBoneData, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_DecompressSkeletalBoneData)(void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace * peTransformSpace, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_DecompressSkeletalBoneData((void *)1, 2, (void *)3, (void *)4, 5);
    check_ptr_parameter("IVRInput_004_DecompressSkeletalBoneData", this_ptr_value);
    check_ptr_parameter("IVRInput_004_DecompressSkeletalBoneData", (void *)1);
    check_uint32_parameter("IVRInput_004_DecompressSkeletalBoneData", 2);
    check_ptr_parameter("IVRInput_004_DecompressSkeletalBoneData", (void *)3);
    check_ptr_parameter("IVRInput_004_DecompressSkeletalBoneData", (void *)4);
    check_uint32_parameter("IVRInput_004_DecompressSkeletalBoneData", 5);

    init_thunk(t, this_ptr_value, IVRInput_004_TriggerHapticVibrationAction, 6, TRUE, TRUE);
    EVRInputError (__stdcall *capi_IVRInput_004_TriggerHapticVibrationAction)(VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_TriggerHapticVibrationAction(1, 2.0f, 3.0f, 4.0f, 5.0f, 6);
    check_ptr_parameter("IVRInput_004_TriggerHapticVibrationAction", this_ptr_value);
    check_uint64_parameter("IVRInput_004_TriggerHapticVibrationAction", 1);
    check_float_parameter("IVRInput_004_TriggerHapticVibrationAction", 2.0f);
    check_float_parameter("IVRInput_004_TriggerHapticVibrationAction", 3.0f);
    check_float_parameter("IVRInput_004_TriggerHapticVibrationAction", 4.0f);
    check_float_parameter("IVRInput_004_TriggerHapticVibrationAction", 5.0f);
    check_uint64_parameter("IVRInput_004_TriggerHapticVibrationAction", 6);

    init_thunk(t, this_ptr_value, IVRInput_004_GetActionOrigins, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_GetActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_GetActionOrigins(1, 2, (void *)3, 4);
    check_ptr_parameter("IVRInput_004_GetActionOrigins", this_ptr_value);
    check_uint64_parameter("IVRInput_004_GetActionOrigins", 1);
    check_uint64_parameter("IVRInput_004_GetActionOrigins", 2);
    check_ptr_parameter("IVRInput_004_GetActionOrigins", (void *)3);
    check_uint32_parameter("IVRInput_004_GetActionOrigins", 4);

    init_thunk(t, this_ptr_value, IVRInput_004_GetOriginLocalizedName, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_GetOriginLocalizedName)(VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_GetOriginLocalizedName(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_004_GetOriginLocalizedName", this_ptr_value);
    check_uint64_parameter("IVRInput_004_GetOriginLocalizedName", 1);
    check_ptr_parameter("IVRInput_004_GetOriginLocalizedName", (void *)2);
    check_uint32_parameter("IVRInput_004_GetOriginLocalizedName", 3);

    init_thunk(t, this_ptr_value, IVRInput_004_GetOriginTrackedDeviceInfo, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_GetOriginTrackedDeviceInfo)(VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_GetOriginTrackedDeviceInfo(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_004_GetOriginTrackedDeviceInfo", this_ptr_value);
    check_uint64_parameter("IVRInput_004_GetOriginTrackedDeviceInfo", 1);
    check_ptr_parameter("IVRInput_004_GetOriginTrackedDeviceInfo", (void *)2);
    check_uint32_parameter("IVRInput_004_GetOriginTrackedDeviceInfo", 3);

    init_thunk(t, this_ptr_value, IVRInput_004_ShowActionOrigins, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_ShowActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_ShowActionOrigins(1, 2);
    check_ptr_parameter("IVRInput_004_ShowActionOrigins", this_ptr_value);
    check_uint64_parameter("IVRInput_004_ShowActionOrigins", 1);
    check_uint64_parameter("IVRInput_004_ShowActionOrigins", 2);

    init_thunk(t, this_ptr_value, IVRInput_004_ShowBindingsForActionSet, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_004_ShowBindingsForActionSet)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight) = (void *)t;

    clear_parameters();
    capi_IVRInput_004_ShowBindingsForActionSet((void *)1, 2, 3, 4);
    check_ptr_parameter("IVRInput_004_ShowBindingsForActionSet", this_ptr_value);
    check_ptr_parameter("IVRInput_004_ShowBindingsForActionSet", (void *)1);
    check_uint32_parameter("IVRInput_004_ShowBindingsForActionSet", 2);
    check_uint32_parameter("IVRInput_004_ShowBindingsForActionSet", 3);
    check_uint64_parameter("IVRInput_004_ShowBindingsForActionSet", 4);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRTrackedCamera_003(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetCameraErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRTrackedCamera_003_GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_003_GetCameraErrorNameFromEnum(1);
    check_ptr_parameter("IVRTrackedCamera_003_GetCameraErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_003_GetCameraErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_HasCamera, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_003_HasCamera(1, (void *)2);
    check_ptr_parameter("IVRTrackedCamera_003_HasCamera", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_003_HasCamera", 1);
    check_ptr_parameter("IVRTrackedCamera_003_HasCamera", (void *)2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetCameraFrameSize, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_003_GetCameraFrameSize(1, 2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_003_GetCameraFrameSize", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_003_GetCameraFrameSize", 1);
    check_uint32_parameter("IVRTrackedCamera_003_GetCameraFrameSize", 2);
    check_ptr_parameter("IVRTrackedCamera_003_GetCameraFrameSize", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_003_GetCameraFrameSize", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_003_GetCameraFrameSize", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetCameraIntrinsics, 4, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetCameraIntrinsics)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_003_GetCameraIntrinsics(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRTrackedCamera_003_GetCameraIntrinsics", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_003_GetCameraIntrinsics", 1);
    check_uint32_parameter("IVRTrackedCamera_003_GetCameraIntrinsics", 2);
    check_ptr_parameter("IVRTrackedCamera_003_GetCameraIntrinsics", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_003_GetCameraIntrinsics", (void *)4);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetCameraProjection, 5, TRUE, TRUE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_003_GetCameraProjection(1, 2, 3.0f, 4.0f, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_003_GetCameraProjection", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_003_GetCameraProjection", 1);
    check_uint32_parameter("IVRTrackedCamera_003_GetCameraProjection", 2);
    check_float_parameter("IVRTrackedCamera_003_GetCameraProjection", 3.0f);
    check_float_parameter("IVRTrackedCamera_003_GetCameraProjection", 4.0f);
    check_ptr_parameter("IVRTrackedCamera_003_GetCameraProjection", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_AcquireVideoStreamingService, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_003_AcquireVideoStreamingService(1, (void *)2);
    check_ptr_parameter("IVRTrackedCamera_003_AcquireVideoStreamingService", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_003_AcquireVideoStreamingService", 1);
    check_ptr_parameter("IVRTrackedCamera_003_AcquireVideoStreamingService", (void *)2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_ReleaseVideoStreamingService, 1, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_003_ReleaseVideoStreamingService(1);
    check_ptr_parameter("IVRTrackedCamera_003_ReleaseVideoStreamingService", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_003_ReleaseVideoStreamingService", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetVideoStreamFrameBuffer, 6, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_003_GetVideoStreamFrameBuffer(1, 2, (void *)3, 4, (void *)5, 6);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", 1);
    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", 2);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", (void *)3);
    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", 4);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", (void *)5);
    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamFrameBuffer", 6);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetVideoStreamTextureSize, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetVideoStreamTextureSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_003_GetVideoStreamTextureSize(1, 2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureSize", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamTextureSize", 1);
    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamTextureSize", 2);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureSize", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureSize", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureSize", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetVideoStreamTextureD3D11, 6, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetVideoStreamTextureD3D11)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_003_GetVideoStreamTextureD3D11(1, 2, (void *)3, (void *)4, (void *)5, 6);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", 1);
    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", 2);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", (void *)5);
    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamTextureD3D11", 6);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_GetVideoStreamTextureGL, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_GetVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_003_GetVideoStreamTextureGL(1, 2, (void *)3, (void *)4, 5);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureGL", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_003_GetVideoStreamTextureGL", 1);
    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamTextureGL", 2);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureGL", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_003_GetVideoStreamTextureGL", (void *)4);
    check_uint32_parameter("IVRTrackedCamera_003_GetVideoStreamTextureGL", 5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_003_ReleaseVideoStreamTextureGL, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_003_ReleaseVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_003_ReleaseVideoStreamTextureGL(1, 2);
    check_ptr_parameter("IVRTrackedCamera_003_ReleaseVideoStreamTextureGL", this_ptr_value);
    check_uint64_parameter("IVRTrackedCamera_003_ReleaseVideoStreamTextureGL", 1);
    check_uint32_parameter("IVRTrackedCamera_003_ReleaseVideoStreamTextureGL", 2);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRRenderModels_005(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_LoadRenderModel_Async, 2, FALSE, FALSE);
    EVRRenderModelError (__stdcall *capi_IVRRenderModels_005_LoadRenderModel_Async)(const char * pchRenderModelName, RenderModel_t ** ppRenderModel) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_LoadRenderModel_Async((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_005_LoadRenderModel_Async", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_005_LoadRenderModel_Async", (void *)1);
    check_ptr_parameter("IVRRenderModels_005_LoadRenderModel_Async", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_FreeRenderModel, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRRenderModels_005_FreeRenderModel)(RenderModel_t * pRenderModel) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_FreeRenderModel((void *)1);
    check_ptr_parameter("IVRRenderModels_005_FreeRenderModel", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_005_FreeRenderModel", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_LoadTexture_Async, 2, FALSE, FALSE);
    EVRRenderModelError (__stdcall *capi_IVRRenderModels_005_LoadTexture_Async)(TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_LoadTexture_Async(1, (void *)2);
    check_ptr_parameter("IVRRenderModels_005_LoadTexture_Async", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_005_LoadTexture_Async", 1);
    check_ptr_parameter("IVRRenderModels_005_LoadTexture_Async", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_FreeTexture, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRRenderModels_005_FreeTexture)(RenderModel_TextureMap_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_FreeTexture((void *)1);
    check_ptr_parameter("IVRRenderModels_005_FreeTexture", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_005_FreeTexture", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_LoadTextureD3D11_Async, 3, FALSE, FALSE);
    EVRRenderModelError (__stdcall *capi_IVRRenderModels_005_LoadTextureD3D11_Async)(TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_LoadTextureD3D11_Async(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRRenderModels_005_LoadTextureD3D11_Async", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_005_LoadTextureD3D11_Async", 1);
    check_ptr_parameter("IVRRenderModels_005_LoadTextureD3D11_Async", (void *)2);
    check_ptr_parameter("IVRRenderModels_005_LoadTextureD3D11_Async", (void *)3);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_LoadIntoTextureD3D11_Async, 2, FALSE, FALSE);
    EVRRenderModelError (__stdcall *capi_IVRRenderModels_005_LoadIntoTextureD3D11_Async)(TextureID_t textureId, void * pDstTexture) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_LoadIntoTextureD3D11_Async(1, (void *)2);
    check_ptr_parameter("IVRRenderModels_005_LoadIntoTextureD3D11_Async", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_005_LoadIntoTextureD3D11_Async", 1);
    check_ptr_parameter("IVRRenderModels_005_LoadIntoTextureD3D11_Async", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_FreeTextureD3D11, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRRenderModels_005_FreeTextureD3D11)(void * pD3D11Texture2D) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_FreeTextureD3D11((void *)1);
    check_ptr_parameter("IVRRenderModels_005_FreeTextureD3D11", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_005_FreeTextureD3D11", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetRenderModelName, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_005_GetRenderModelName)(uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_GetRenderModelName(1, (void *)2, 3);
    check_ptr_parameter("IVRRenderModels_005_GetRenderModelName", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_005_GetRenderModelName", 1);
    check_ptr_parameter("IVRRenderModels_005_GetRenderModelName", (void *)2);
    check_uint32_parameter("IVRRenderModels_005_GetRenderModelName", 3);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetRenderModelCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_005_GetRenderModelCount)() = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_GetRenderModelCount();
    check_ptr_parameter("IVRRenderModels_005_GetRenderModelCount", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetComponentCount, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_005_GetComponentCount)(const char * pchRenderModelName) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_GetComponentCount((void *)1);
    check_ptr_parameter("IVRRenderModels_005_GetComponentCount", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_005_GetComponentCount", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetComponentName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_005_GetComponentName)(const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_GetComponentName((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRRenderModels_005_GetComponentName", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_005_GetComponentName", (void *)1);
    check_uint32_parameter("IVRRenderModels_005_GetComponentName", 2);
    check_ptr_parameter("IVRRenderModels_005_GetComponentName", (void *)3);
    check_uint32_parameter("IVRRenderModels_005_GetComponentName", 4);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetComponentButtonMask, 2, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRRenderModels_005_GetComponentButtonMask)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_GetComponentButtonMask((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_005_GetComponentButtonMask", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_005_GetComponentButtonMask", (void *)1);
    check_ptr_parameter("IVRRenderModels_005_GetComponentButtonMask", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetComponentRenderModelName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_005_GetComponentRenderModelName)(const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_GetComponentRenderModelName((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRRenderModels_005_GetComponentRenderModelName", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_005_GetComponentRenderModelName", (void *)1);
    check_ptr_parameter("IVRRenderModels_005_GetComponentRenderModelName", (void *)2);
    check_ptr_parameter("IVRRenderModels_005_GetComponentRenderModelName", (void *)3);
    check_uint32_parameter("IVRRenderModels_005_GetComponentRenderModelName", 4);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetComponentState, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRRenderModels_005_GetComponentState)(const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_GetComponentState((void *)1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRRenderModels_005_GetComponentState", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_005_GetComponentState", (void *)1);
    check_ptr_parameter("IVRRenderModels_005_GetComponentState", (void *)2);
    check_ptr_parameter("IVRRenderModels_005_GetComponentState", (void *)3);
    check_ptr_parameter("IVRRenderModels_005_GetComponentState", (void *)4);
    check_ptr_parameter("IVRRenderModels_005_GetComponentState", (void *)5);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_RenderModelHasComponent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRRenderModels_005_RenderModelHasComponent)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_RenderModelHasComponent((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_005_RenderModelHasComponent", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_005_RenderModelHasComponent", (void *)1);
    check_ptr_parameter("IVRRenderModels_005_RenderModelHasComponent", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetRenderModelThumbnailURL, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_005_GetRenderModelThumbnailURL)(const char * pchRenderModelName, char * pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError * peError) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_GetRenderModelThumbnailURL((void *)1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRRenderModels_005_GetRenderModelThumbnailURL", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_005_GetRenderModelThumbnailURL", (void *)1);
    check_ptr_parameter("IVRRenderModels_005_GetRenderModelThumbnailURL", (void *)2);
    check_uint32_parameter("IVRRenderModels_005_GetRenderModelThumbnailURL", 3);
    check_ptr_parameter("IVRRenderModels_005_GetRenderModelThumbnailURL", (void *)4);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetRenderModelOriginalPath, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_005_GetRenderModelOriginalPath)(const char * pchRenderModelName, char * pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError * peError) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_GetRenderModelOriginalPath((void *)1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRRenderModels_005_GetRenderModelOriginalPath", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_005_GetRenderModelOriginalPath", (void *)1);
    check_ptr_parameter("IVRRenderModels_005_GetRenderModelOriginalPath", (void *)2);
    check_uint32_parameter("IVRRenderModels_005_GetRenderModelOriginalPath", 3);
    check_ptr_parameter("IVRRenderModels_005_GetRenderModelOriginalPath", (void *)4);

    init_thunk(t, this_ptr_value, IVRRenderModels_005_GetRenderModelErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRRenderModels_005_GetRenderModelErrorNameFromEnum)(EVRRenderModelError error) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_005_GetRenderModelErrorNameFromEnum(1);
    check_ptr_parameter("IVRRenderModels_005_GetRenderModelErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_005_GetRenderModelErrorNameFromEnum", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRInput_003(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRInput_003_SetActionManifestPath, 1, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_SetActionManifestPath)(const char * pchActionManifestPath) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_SetActionManifestPath((void *)1);
    check_ptr_parameter("IVRInput_003_SetActionManifestPath", this_ptr_value);
    check_ptr_parameter("IVRInput_003_SetActionManifestPath", (void *)1);

    init_thunk(t, this_ptr_value, IVRInput_003_GetActionSetHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_GetActionSetHandle)(const char * pchActionSetName, VRActionSetHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_GetActionSetHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_003_GetActionSetHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_003_GetActionSetHandle", (void *)1);
    check_ptr_parameter("IVRInput_003_GetActionSetHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_003_GetActionHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_GetActionHandle)(const char * pchActionName, VRActionHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_GetActionHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_003_GetActionHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_003_GetActionHandle", (void *)1);
    check_ptr_parameter("IVRInput_003_GetActionHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_003_GetInputSourceHandle, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_GetInputSourceHandle)(const char * pchInputSourcePath, VRInputValueHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_GetInputSourceHandle((void *)1, (void *)2);
    check_ptr_parameter("IVRInput_003_GetInputSourceHandle", this_ptr_value);
    check_ptr_parameter("IVRInput_003_GetInputSourceHandle", (void *)1);
    check_ptr_parameter("IVRInput_003_GetInputSourceHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVRInput_003_UpdateActionState, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_UpdateActionState)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_UpdateActionState((void *)1, 2, 3);
    check_ptr_parameter("IVRInput_003_UpdateActionState", this_ptr_value);
    check_ptr_parameter("IVRInput_003_UpdateActionState", (void *)1);
    check_uint32_parameter("IVRInput_003_UpdateActionState", 2);
    check_uint32_parameter("IVRInput_003_UpdateActionState", 3);

    init_thunk(t, this_ptr_value, IVRInput_003_GetDigitalActionData, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_GetDigitalActionData)(VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_GetDigitalActionData(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_003_GetDigitalActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_003_GetDigitalActionData", 1);
    check_ptr_parameter("IVRInput_003_GetDigitalActionData", (void *)2);
    check_uint32_parameter("IVRInput_003_GetDigitalActionData", 3);

    init_thunk(t, this_ptr_value, IVRInput_003_GetAnalogActionData, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_GetAnalogActionData)(VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_GetAnalogActionData(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_003_GetAnalogActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_003_GetAnalogActionData", 1);
    check_ptr_parameter("IVRInput_003_GetAnalogActionData", (void *)2);
    check_uint32_parameter("IVRInput_003_GetAnalogActionData", 3);

    init_thunk(t, this_ptr_value, IVRInput_003_GetPoseActionData, 5, TRUE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_GetPoseActionData)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_GetPoseActionData(1, 2, 3.0f, (void *)4, 5);
    check_ptr_parameter("IVRInput_003_GetPoseActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_003_GetPoseActionData", 1);
    check_uint32_parameter("IVRInput_003_GetPoseActionData", 2);
    check_float_parameter("IVRInput_003_GetPoseActionData", 3.0f);
    check_ptr_parameter("IVRInput_003_GetPoseActionData", (void *)4);
    check_uint32_parameter("IVRInput_003_GetPoseActionData", 5);

    init_thunk(t, this_ptr_value, IVRInput_003_GetSkeletalActionData, 7, TRUE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_GetSkeletalActionData)(VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, InputSkeletonActionData_t * pActionData, uint32_t unActionDataSize, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_GetSkeletalActionData(1, 2, 3.0f, (void *)4, 5, (void *)6, 7);
    check_ptr_parameter("IVRInput_003_GetSkeletalActionData", this_ptr_value);
    check_uint64_parameter("IVRInput_003_GetSkeletalActionData", 1);
    check_uint32_parameter("IVRInput_003_GetSkeletalActionData", 2);
    check_float_parameter("IVRInput_003_GetSkeletalActionData", 3.0f);
    check_ptr_parameter("IVRInput_003_GetSkeletalActionData", (void *)4);
    check_uint32_parameter("IVRInput_003_GetSkeletalActionData", 5);
    check_ptr_parameter("IVRInput_003_GetSkeletalActionData", (void *)6);
    check_uint32_parameter("IVRInput_003_GetSkeletalActionData", 7);

    init_thunk(t, this_ptr_value, IVRInput_003_GetSkeletalActionDataCompressed, 6, TRUE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_GetSkeletalActionDataCompressed)(VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_GetSkeletalActionDataCompressed(1, 2, 3.0f, (void *)4, 5, (void *)6);
    check_ptr_parameter("IVRInput_003_GetSkeletalActionDataCompressed", this_ptr_value);
    check_uint64_parameter("IVRInput_003_GetSkeletalActionDataCompressed", 1);
    check_uint32_parameter("IVRInput_003_GetSkeletalActionDataCompressed", 2);
    check_float_parameter("IVRInput_003_GetSkeletalActionDataCompressed", 3.0f);
    check_ptr_parameter("IVRInput_003_GetSkeletalActionDataCompressed", (void *)4);
    check_uint32_parameter("IVRInput_003_GetSkeletalActionDataCompressed", 5);
    check_ptr_parameter("IVRInput_003_GetSkeletalActionDataCompressed", (void *)6);

    init_thunk(t, this_ptr_value, IVRInput_003_UncompressSkeletalActionData, 5, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_UncompressSkeletalActionData)(void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace * peBoneParent, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_UncompressSkeletalActionData((void *)1, 2, (void *)3, (void *)4, 5);
    check_ptr_parameter("IVRInput_003_UncompressSkeletalActionData", this_ptr_value);
    check_ptr_parameter("IVRInput_003_UncompressSkeletalActionData", (void *)1);
    check_uint32_parameter("IVRInput_003_UncompressSkeletalActionData", 2);
    check_ptr_parameter("IVRInput_003_UncompressSkeletalActionData", (void *)3);
    check_ptr_parameter("IVRInput_003_UncompressSkeletalActionData", (void *)4);
    check_uint32_parameter("IVRInput_003_UncompressSkeletalActionData", 5);

    init_thunk(t, this_ptr_value, IVRInput_003_TriggerHapticVibrationAction, 5, TRUE, TRUE);
    EVRInputError (__stdcall *capi_IVRInput_003_TriggerHapticVibrationAction)(VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_TriggerHapticVibrationAction(1, 2.0f, 3.0f, 4.0f, 5.0f);
    check_ptr_parameter("IVRInput_003_TriggerHapticVibrationAction", this_ptr_value);
    check_uint64_parameter("IVRInput_003_TriggerHapticVibrationAction", 1);
    check_float_parameter("IVRInput_003_TriggerHapticVibrationAction", 2.0f);
    check_float_parameter("IVRInput_003_TriggerHapticVibrationAction", 3.0f);
    check_float_parameter("IVRInput_003_TriggerHapticVibrationAction", 4.0f);
    check_float_parameter("IVRInput_003_TriggerHapticVibrationAction", 5.0f);

    init_thunk(t, this_ptr_value, IVRInput_003_GetActionOrigins, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_GetActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_GetActionOrigins(1, 2, (void *)3, 4);
    check_ptr_parameter("IVRInput_003_GetActionOrigins", this_ptr_value);
    check_uint64_parameter("IVRInput_003_GetActionOrigins", 1);
    check_uint64_parameter("IVRInput_003_GetActionOrigins", 2);
    check_ptr_parameter("IVRInput_003_GetActionOrigins", (void *)3);
    check_uint32_parameter("IVRInput_003_GetActionOrigins", 4);

    init_thunk(t, this_ptr_value, IVRInput_003_GetOriginLocalizedName, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_GetOriginLocalizedName)(VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_GetOriginLocalizedName(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_003_GetOriginLocalizedName", this_ptr_value);
    check_uint64_parameter("IVRInput_003_GetOriginLocalizedName", 1);
    check_ptr_parameter("IVRInput_003_GetOriginLocalizedName", (void *)2);
    check_uint32_parameter("IVRInput_003_GetOriginLocalizedName", 3);

    init_thunk(t, this_ptr_value, IVRInput_003_GetOriginTrackedDeviceInfo, 3, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_GetOriginTrackedDeviceInfo)(VRInputValueHandle_t origin, InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_GetOriginTrackedDeviceInfo(1, (void *)2, 3);
    check_ptr_parameter("IVRInput_003_GetOriginTrackedDeviceInfo", this_ptr_value);
    check_uint64_parameter("IVRInput_003_GetOriginTrackedDeviceInfo", 1);
    check_ptr_parameter("IVRInput_003_GetOriginTrackedDeviceInfo", (void *)2);
    check_uint32_parameter("IVRInput_003_GetOriginTrackedDeviceInfo", 3);

    init_thunk(t, this_ptr_value, IVRInput_003_ShowActionOrigins, 2, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_ShowActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_ShowActionOrigins(1, 2);
    check_ptr_parameter("IVRInput_003_ShowActionOrigins", this_ptr_value);
    check_uint64_parameter("IVRInput_003_ShowActionOrigins", 1);
    check_uint64_parameter("IVRInput_003_ShowActionOrigins", 2);

    init_thunk(t, this_ptr_value, IVRInput_003_ShowBindingsForActionSet, 4, FALSE, FALSE);
    EVRInputError (__stdcall *capi_IVRInput_003_ShowBindingsForActionSet)(VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight) = (void *)t;

    clear_parameters();
    capi_IVRInput_003_ShowBindingsForActionSet((void *)1, 2, 3, 4);
    check_ptr_parameter("IVRInput_003_ShowBindingsForActionSet", this_ptr_value);
    check_ptr_parameter("IVRInput_003_ShowBindingsForActionSet", (void *)1);
    check_uint32_parameter("IVRInput_003_ShowBindingsForActionSet", 2);
    check_uint32_parameter("IVRInput_003_ShowBindingsForActionSet", 3);
    check_uint64_parameter("IVRInput_003_ShowBindingsForActionSet", 4);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_017(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_017_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_017_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_017_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_017_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetProjectionMatrix, 4, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_017_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_017_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_017_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_017_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_017_GetProjectionMatrix", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_017_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_017_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_017_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_017_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_017_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_017_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_017_ComputeDistortion, 4, TRUE, FALSE);
    bool (__stdcall *capi_IVRSystem_017_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
    check_ptr_parameter("IVRSystem_017_ComputeDistortion", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_017_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_017_ComputeDistortion", 3.0f);
    check_ptr_parameter("IVRSystem_017_ComputeDistortion", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_017_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_017_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_017_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_017_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_017_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_017_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_017_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_017_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_017_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetDXGIOutputInfo, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_017_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetDXGIOutputInfo((void *)1);
    check_ptr_parameter("IVRSystem_017_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_017_GetDXGIOutputInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetOutputDevice, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_017_GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetOutputDevice((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_017_GetOutputDevice", this_ptr_value);
    check_ptr_parameter("IVRSystem_017_GetOutputDevice", (void *)1);
    check_uint32_parameter("IVRSystem_017_GetOutputDevice", 2);
    check_ptr_parameter("IVRSystem_017_GetOutputDevice", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_017_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_017_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_017_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_017_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_017_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_017_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_017_SetDisplayVisibility", 1);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_017_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_017_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_017_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_017_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_017_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_017_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_017_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_017_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_017_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_017_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_017_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_017_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_017_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_017_ApplyTransform, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_017_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_ApplyTransform((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_017_ApplyTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_017_ApplyTransform", (void *)1);
    check_ptr_parameter("IVRSystem_017_ApplyTransform", (void *)2);
    check_ptr_parameter("IVRSystem_017_ApplyTransform", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_017_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetTrackedDeviceIndexForControllerRole(1);
    check_ptr_parameter("IVRSystem_017_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetTrackedDeviceIndexForControllerRole", 1);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
    ETrackedControllerRole (__stdcall *capi_IVRSystem_017_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetControllerRoleForTrackedDeviceIndex(1);
    check_ptr_parameter("IVRSystem_017_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetControllerRoleForTrackedDeviceIndex", 1);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetTrackedDeviceClass, 1, FALSE, FALSE);
    ETrackedDeviceClass (__stdcall *capi_IVRSystem_017_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_017_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_017_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_017_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_017_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_017_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_017_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_017_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_017_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_017_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_017_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_017_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_017_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_017_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_017_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_017_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_017_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_017_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_017_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_017_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_017_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_017_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_017_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_017_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_017_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_017_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_017_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_017_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_017_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_017_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_017_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_017_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_017_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_017_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_017_PollNextEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_017_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_PollNextEvent((void *)1, 2);
    check_ptr_parameter("IVRSystem_017_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_017_PollNextEvent", (void *)1);
    check_uint32_parameter("IVRSystem_017_PollNextEvent", 2);

    init_thunk(t, this_ptr_value, IVRSystem_017_PollNextEventWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_017_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSystem_017_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_017_PollNextEventWithPose", (void *)2);
    check_uint32_parameter("IVRSystem_017_PollNextEventWithPose", 3);
    check_ptr_parameter("IVRSystem_017_PollNextEventWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_017_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_017_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetHiddenAreaMesh, 3, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_017_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetHiddenAreaMesh(data_ptr_value, 1, 2);
    check_ptr_parameter("IVRSystem_017_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_017_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetHiddenAreaMesh", 1);
    check_uint32_parameter("IVRSystem_017_GetHiddenAreaMesh", 2);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetControllerState, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_017_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetControllerState(1, (void *)2, 3);
    check_ptr_parameter("IVRSystem_017_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_017_GetControllerState", (void *)2);
    check_uint32_parameter("IVRSystem_017_GetControllerState", 3);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetControllerStateWithPose, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_017_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_017_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_017_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_017_GetControllerStateWithPose", (void *)3);
    check_uint32_parameter("IVRSystem_017_GetControllerStateWithPose", 4);
    check_ptr_parameter("IVRSystem_017_GetControllerStateWithPose", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_017_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_017_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_017_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_017_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_017_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_017_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_017_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_017_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_017_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_017_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_017_CaptureInputFocus, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_017_CaptureInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_CaptureInputFocus();
    check_ptr_parameter("IVRSystem_017_CaptureInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_017_ReleaseInputFocus, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_017_ReleaseInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_ReleaseInputFocus();
    check_ptr_parameter("IVRSystem_017_ReleaseInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_017_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_017_IsInputFocusCapturedByAnotherProcess)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_IsInputFocusCapturedByAnotherProcess();
    check_ptr_parameter("IVRSystem_017_IsInputFocusCapturedByAnotherProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_017_DriverDebugRequest, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_017_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_DriverDebugRequest(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRSystem_017_DriverDebugRequest", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_DriverDebugRequest", 1);
    check_ptr_parameter("IVRSystem_017_DriverDebugRequest", (void *)2);
    check_ptr_parameter("IVRSystem_017_DriverDebugRequest", (void *)3);
    check_uint32_parameter("IVRSystem_017_DriverDebugRequest", 4);

    init_thunk(t, this_ptr_value, IVRSystem_017_PerformFirmwareUpdate, 1, FALSE, FALSE);
    EVRFirmwareError (__stdcall *capi_IVRSystem_017_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_017_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_017_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_017_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_017_AcknowledgeQuit_Exiting)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_AcknowledgeQuit_Exiting();
    check_ptr_parameter("IVRSystem_017_AcknowledgeQuit_Exiting", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_017_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_017_AcknowledgeQuit_UserPrompt)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_017_AcknowledgeQuit_UserPrompt();
    check_ptr_parameter("IVRSystem_017_AcknowledgeQuit_UserPrompt", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_017(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_017_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_017_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_017_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_017_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_017_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_017_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_017_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_017_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_017_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetHighQualityOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_017_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_017_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_017_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_017_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_017_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_017_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_017_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_017_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_017_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_017_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_017_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayName, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayName(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_SetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayName", 1);
    check_ptr_parameter("IVROverlay_017_SetOverlayName", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_017_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_017_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_017_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_017_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_017_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_017_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_017_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_017_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_017_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_017_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_017_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_017_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_017_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_017_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_017_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_017_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_017_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_017_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_017_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_017_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_017_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_017_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_017_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_017_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_017_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTexelAspect, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayTexelAspect(1, 2.0f);
    check_ptr_parameter("IVROverlay_017_SetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayTexelAspect", 1);
    check_float_parameter("IVROverlay_017_SetOverlayTexelAspect", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTexelAspect, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayTexelAspect(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayTexelAspect", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayTexelAspect", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlaySortOrder(1, 2);
    check_ptr_parameter("IVROverlay_017_SetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlaySortOrder", 1);
    check_uint32_parameter("IVROverlay_017_SetOverlaySortOrder", 2);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlaySortOrder(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlaySortOrder", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlaySortOrder", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_017_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_017_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_017_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_017_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_017_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_017_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayRenderModel, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_017_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_017_GetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayRenderModel", (void *)2);
    check_uint32_parameter("IVROverlay_017_GetOverlayRenderModel", 3);
    check_ptr_parameter("IVROverlay_017_GetOverlayRenderModel", (void *)4);
    check_ptr_parameter("IVROverlay_017_GetOverlayRenderModel", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayRenderModel, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayRenderModel(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_017_SetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_017_SetOverlayRenderModel", (void *)2);
    check_ptr_parameter("IVROverlay_017_SetOverlayRenderModel", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_017_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_017_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_017_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_017_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_017_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayTransformOverlayRelative", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformOverlayRelative", (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_017_SetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayTransformOverlayRelative", 1);
    check_uint64_parameter("IVROverlay_017_SetOverlayTransformOverlayRelative", 2);
    check_ptr_parameter("IVROverlay_017_SetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_017_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_017_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_HideOverlay(1);
    check_ptr_parameter("IVROverlay_017_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_017_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_017_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_017_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_017_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_017_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_017_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_017_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_017_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_017_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_017_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_017_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_017_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_017_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_017_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_017_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_017_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_017_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_017_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_017_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_017_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_017_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_017_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_017_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_017_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_017_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetGamepadFocusOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_017_GetGamepadFocusOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetGamepadFocusOverlay();
    check_ptr_parameter("IVROverlay_017_GetGamepadFocusOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetGamepadFocusOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetGamepadFocusOverlay(1);
    check_ptr_parameter("IVROverlay_017_SetGamepadFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetGamepadFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayNeighbor, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayNeighbor(1, 2, 3);
    check_ptr_parameter("IVROverlay_017_SetOverlayNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_017_SetOverlayNeighbor", 1);
    check_uint64_parameter("IVROverlay_017_SetOverlayNeighbor", 2);
    check_uint64_parameter("IVROverlay_017_SetOverlayNeighbor", 3);

    init_thunk(t, this_ptr_value, IVROverlay_017_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_MoveGamepadFocusToNeighbor(1, 2);
    check_ptr_parameter("IVROverlay_017_MoveGamepadFocusToNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_017_MoveGamepadFocusToNeighbor", 1);
    check_uint64_parameter("IVROverlay_017_MoveGamepadFocusToNeighbor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayDualAnalogTransform, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * vCenter, float fRadius) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayDualAnalogTransform(1, 2, (void *)3, 4.0f);
    check_ptr_parameter("IVROverlay_017_SetOverlayDualAnalogTransform", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayDualAnalogTransform", 1);
    check_uint32_parameter("IVROverlay_017_SetOverlayDualAnalogTransform", 2);
    check_ptr_parameter("IVROverlay_017_SetOverlayDualAnalogTransform", (void *)3);
    check_float_parameter("IVROverlay_017_SetOverlayDualAnalogTransform", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayDualAnalogTransform, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayDualAnalogTransform(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_017_GetOverlayDualAnalogTransform", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayDualAnalogTransform", 1);
    check_uint32_parameter("IVROverlay_017_GetOverlayDualAnalogTransform", 2);
    check_ptr_parameter("IVROverlay_017_GetOverlayDualAnalogTransform", (void *)3);
    check_ptr_parameter("IVROverlay_017_GetOverlayDualAnalogTransform", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_017_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_017_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_017_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_017_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_017_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_017_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_017_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_017_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTexture, 9, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)8);
    check_ptr_parameter("IVROverlay_017_GetOverlayTexture", (void *)9);

    init_thunk(t, this_ptr_value, IVROverlay_017_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_017_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayTextureSize, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayTextureSize(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_017_GetOverlayTextureSize", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayTextureSize", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayTextureSize", (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayTextureSize", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_017_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_017_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_017_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_017_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_017_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_017_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_017_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_017_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_017_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_017_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_017_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_017_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_017_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_017_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_017_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_017_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_017_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_017_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_017_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_017_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_017_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_017_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_017_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_017_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_017_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_017_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_017_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_017_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_017_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_017_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_017_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_017_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_017_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_017_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_017_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_017_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_017_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_017_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_017_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_017_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_017_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_017_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_017_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_017_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_HideKeyboard();
    check_ptr_parameter("IVROverlay_017_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_017_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_017_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_017_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_017_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_017_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_017_SetKeyboardPositionForOverlay", DEFAULT_RECT);

    init_thunk(t, this_ptr_value, IVROverlay_017_SetOverlayIntersectionMask, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
    check_ptr_parameter("IVROverlay_017_SetOverlayIntersectionMask", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_SetOverlayIntersectionMask", 1);
    check_ptr_parameter("IVROverlay_017_SetOverlayIntersectionMask", (void *)2);
    check_uint32_parameter("IVROverlay_017_SetOverlayIntersectionMask", 3);
    check_uint32_parameter("IVROverlay_017_SetOverlayIntersectionMask", 4);

    init_thunk(t, this_ptr_value, IVROverlay_017_GetOverlayFlags, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_017_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_GetOverlayFlags(1, (void *)2);
    check_ptr_parameter("IVROverlay_017_GetOverlayFlags", this_ptr_value);
    check_uint64_parameter("IVROverlay_017_GetOverlayFlags", 1);
    check_ptr_parameter("IVROverlay_017_GetOverlayFlags", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_017_ShowMessageOverlay, 6, FALSE, FALSE);
    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_017_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", (void *)4);
    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", (void *)5);
    check_ptr_parameter("IVROverlay_017_ShowMessageOverlay", (void *)6);

    init_thunk(t, this_ptr_value, IVROverlay_017_CloseMessageOverlay, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_017_CloseMessageOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_017_CloseMessageOverlay();
    check_ptr_parameter("IVROverlay_017_CloseMessageOverlay", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_021(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_021_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_021_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_021_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_021_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_021_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_021_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_021_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_021_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_021_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_021_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_021_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_021_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_021_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_021_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_021_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_021_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_021_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_021_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_021_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_021_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_021_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_021_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_021_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_021_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_021_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_021_Submit", 1);
    check_ptr_parameter("IVRCompositor_021_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_021_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_021_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_021_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_021_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_021_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_021_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_021_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_021_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_021_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetFrameTimings, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_021_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetFrameTimings((void *)1, 2);
    check_ptr_parameter("IVRCompositor_021_GetFrameTimings", this_ptr_value);
    check_ptr_parameter("IVRCompositor_021_GetFrameTimings", (void *)1);
    check_uint32_parameter("IVRCompositor_021_GetFrameTimings", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_021_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_021_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetCumulativeStats, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetCumulativeStats((void *)1, 2);
    check_ptr_parameter("IVRCompositor_021_GetCumulativeStats", this_ptr_value);
    check_ptr_parameter("IVRCompositor_021_GetCumulativeStats", (void *)1);
    check_uint32_parameter("IVRCompositor_021_GetCumulativeStats", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_021_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_021_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_021_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_021_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_021_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_021_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_021_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_021_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_021_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetCurrentFadeColor, 2, FALSE, FALSE);
    HmdColor_t *(__stdcall *capi_IVRCompositor_021_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetCurrentFadeColor(data_ptr_value, 1);
    check_ptr_parameter("IVRCompositor_021_GetCurrentFadeColor", this_ptr_value);
    check_ptr_parameter("IVRCompositor_021_GetCurrentFadeColor", data_ptr_value);
    check_bool_parameter("IVRCompositor_021_GetCurrentFadeColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_021_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_021_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_021_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_021_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetCurrentGridAlpha, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_021_GetCurrentGridAlpha)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetCurrentGridAlpha();
    check_ptr_parameter("IVRCompositor_021_GetCurrentGridAlpha", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_021_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_021_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_021_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_021_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_021_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_021_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_021_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_021_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_CompositorQuit();
    check_ptr_parameter("IVRCompositor_021_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_021_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_IsFullscreen();
    check_ptr_parameter("IVRCompositor_021_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_021_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_021_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_021_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_021_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_021_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_CanRenderScene();
    check_ptr_parameter("IVRCompositor_021_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_021_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_021_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_021_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_021_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_021_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_021_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_021_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_021_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_021_ForceInterleavedReprojectionOn", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_021_ForceReconnectProcess, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_ForceReconnectProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_ForceReconnectProcess();
    check_ptr_parameter("IVRCompositor_021_ForceReconnectProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_021_SuspendRendering, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_SuspendRendering)(bool bSuspend) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_SuspendRendering(1);
    check_ptr_parameter("IVRCompositor_021_SuspendRendering", this_ptr_value);
    check_bool_parameter("IVRCompositor_021_SuspendRendering", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetMirrorTextureD3D11, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_021_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_021_GetMirrorTextureD3D11", this_ptr_value);
    check_uint32_parameter("IVRCompositor_021_GetMirrorTextureD3D11", 1);
    check_ptr_parameter("IVRCompositor_021_GetMirrorTextureD3D11", (void *)2);
    check_ptr_parameter("IVRCompositor_021_GetMirrorTextureD3D11", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_021_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_ReleaseMirrorTextureD3D11((void *)1);
    check_ptr_parameter("IVRCompositor_021_ReleaseMirrorTextureD3D11", this_ptr_value);
    check_ptr_parameter("IVRCompositor_021_ReleaseMirrorTextureD3D11", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetMirrorTextureGL, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_021_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetMirrorTextureGL(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_021_GetMirrorTextureGL", this_ptr_value);
    check_uint32_parameter("IVRCompositor_021_GetMirrorTextureGL", 1);
    check_ptr_parameter("IVRCompositor_021_GetMirrorTextureGL", (void *)2);
    check_ptr_parameter("IVRCompositor_021_GetMirrorTextureGL", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_021_ReleaseSharedGLTexture, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_021_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_ReleaseSharedGLTexture(1, (void *)2);
    check_ptr_parameter("IVRCompositor_021_ReleaseSharedGLTexture", this_ptr_value);
    check_uint32_parameter("IVRCompositor_021_ReleaseSharedGLTexture", 1);
    check_ptr_parameter("IVRCompositor_021_ReleaseSharedGLTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_021_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_LockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_021_LockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_021_LockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_021_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_UnlockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_021_UnlockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_021_UnlockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_021_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetVulkanInstanceExtensionsRequired((void *)1, 2);
    check_ptr_parameter("IVRCompositor_021_GetVulkanInstanceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_021_GetVulkanInstanceExtensionsRequired", (void *)1);
    check_uint32_parameter("IVRCompositor_021_GetVulkanInstanceExtensionsRequired", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_021_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_021_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRCompositor_021_GetVulkanDeviceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_021_GetVulkanDeviceExtensionsRequired", (void *)1);
    check_ptr_parameter("IVRCompositor_021_GetVulkanDeviceExtensionsRequired", (void *)2);
    check_uint32_parameter("IVRCompositor_021_GetVulkanDeviceExtensionsRequired", 3);

    init_thunk(t, this_ptr_value, IVRCompositor_021_SetExplicitTimingMode, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_021_SetExplicitTimingMode)(bool bExplicitTimingMode) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_SetExplicitTimingMode(1);
    check_ptr_parameter("IVRCompositor_021_SetExplicitTimingMode", this_ptr_value);
    check_bool_parameter("IVRCompositor_021_SetExplicitTimingMode", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_021_SubmitExplicitTimingData, 0, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_021_SubmitExplicitTimingData)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_021_SubmitExplicitTimingData();
    check_ptr_parameter("IVRCompositor_021_SubmitExplicitTimingData", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_016(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_016_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_016_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_016_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_016_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_016_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_016_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_016_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_016_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_016_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetHighQualityOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_016_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_016_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_016_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_016_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_016_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_016_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_016_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_016_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_016_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_016_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_016_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayName, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayName(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_SetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayName", 1);
    check_ptr_parameter("IVROverlay_016_SetOverlayName", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_016_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_016_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_016_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_016_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_016_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_016_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_016_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_016_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_016_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_016_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_016_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_016_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_016_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_016_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_016_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_016_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_016_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_016_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_016_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_016_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_016_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_016_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_016_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_016_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_016_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTexelAspect, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayTexelAspect(1, 2.0f);
    check_ptr_parameter("IVROverlay_016_SetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayTexelAspect", 1);
    check_float_parameter("IVROverlay_016_SetOverlayTexelAspect", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTexelAspect, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayTexelAspect(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayTexelAspect", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayTexelAspect", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlaySortOrder(1, 2);
    check_ptr_parameter("IVROverlay_016_SetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlaySortOrder", 1);
    check_uint32_parameter("IVROverlay_016_SetOverlaySortOrder", 2);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlaySortOrder(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlaySortOrder", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlaySortOrder", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_016_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_016_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_016_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_016_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_016_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_016_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayRenderModel, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_016_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_016_GetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayRenderModel", (void *)2);
    check_uint32_parameter("IVROverlay_016_GetOverlayRenderModel", 3);
    check_ptr_parameter("IVROverlay_016_GetOverlayRenderModel", (void *)4);
    check_ptr_parameter("IVROverlay_016_GetOverlayRenderModel", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayRenderModel, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayRenderModel(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_016_SetOverlayRenderModel", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayRenderModel", 1);
    check_ptr_parameter("IVROverlay_016_SetOverlayRenderModel", (void *)2);
    check_ptr_parameter("IVROverlay_016_SetOverlayRenderModel", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_016_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_016_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_016_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_016_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_016_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayTransformOverlayRelative", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformOverlayRelative", (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_016_SetOverlayTransformOverlayRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayTransformOverlayRelative", 1);
    check_uint64_parameter("IVROverlay_016_SetOverlayTransformOverlayRelative", 2);
    check_ptr_parameter("IVROverlay_016_SetOverlayTransformOverlayRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_016_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_016_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_HideOverlay(1);
    check_ptr_parameter("IVROverlay_016_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_016_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_016_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_016_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_016_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_016_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_016_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_016_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_016_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_016_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_016_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_016_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_016_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_016_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_016_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_016_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_016_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_016_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_016_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_016_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_016_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_016_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_016_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_016_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_016_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_016_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetGamepadFocusOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_016_GetGamepadFocusOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetGamepadFocusOverlay();
    check_ptr_parameter("IVROverlay_016_GetGamepadFocusOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetGamepadFocusOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetGamepadFocusOverlay(1);
    check_ptr_parameter("IVROverlay_016_SetGamepadFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetGamepadFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayNeighbor, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayNeighbor(1, 2, 3);
    check_ptr_parameter("IVROverlay_016_SetOverlayNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_016_SetOverlayNeighbor", 1);
    check_uint64_parameter("IVROverlay_016_SetOverlayNeighbor", 2);
    check_uint64_parameter("IVROverlay_016_SetOverlayNeighbor", 3);

    init_thunk(t, this_ptr_value, IVROverlay_016_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_MoveGamepadFocusToNeighbor(1, 2);
    check_ptr_parameter("IVROverlay_016_MoveGamepadFocusToNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_016_MoveGamepadFocusToNeighbor", 1);
    check_uint64_parameter("IVROverlay_016_MoveGamepadFocusToNeighbor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_016_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_016_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_016_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_016_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_016_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_016_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_016_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_016_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTexture, 9, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)8);
    check_ptr_parameter("IVROverlay_016_GetOverlayTexture", (void *)9);

    init_thunk(t, this_ptr_value, IVROverlay_016_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_016_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayTextureSize, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayTextureSize(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_016_GetOverlayTextureSize", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayTextureSize", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayTextureSize", (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayTextureSize", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_016_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_016_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_016_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_016_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_016_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_016_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_016_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_016_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_016_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_016_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_016_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_016_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_016_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_016_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_016_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_016_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_016_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_016_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_016_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_016_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_016_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_016_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_016_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_016_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_016_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_016_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_016_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_016_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_016_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_016_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_016_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_016_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_016_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_016_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_016_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_016_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_016_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_016_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_016_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_016_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_016_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_016_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_016_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_016_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_HideKeyboard();
    check_ptr_parameter("IVROverlay_016_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_016_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_016_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_016_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_016_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_016_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_016_SetKeyboardPositionForOverlay", DEFAULT_RECT);

    init_thunk(t, this_ptr_value, IVROverlay_016_SetOverlayIntersectionMask, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
    check_ptr_parameter("IVROverlay_016_SetOverlayIntersectionMask", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_SetOverlayIntersectionMask", 1);
    check_ptr_parameter("IVROverlay_016_SetOverlayIntersectionMask", (void *)2);
    check_uint32_parameter("IVROverlay_016_SetOverlayIntersectionMask", 3);
    check_uint32_parameter("IVROverlay_016_SetOverlayIntersectionMask", 4);

    init_thunk(t, this_ptr_value, IVROverlay_016_GetOverlayFlags, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_016_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_GetOverlayFlags(1, (void *)2);
    check_ptr_parameter("IVROverlay_016_GetOverlayFlags", this_ptr_value);
    check_uint64_parameter("IVROverlay_016_GetOverlayFlags", 1);
    check_ptr_parameter("IVROverlay_016_GetOverlayFlags", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_016_ShowMessageOverlay, 6, FALSE, FALSE);
    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_016_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", (void *)4);
    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", (void *)5);
    check_ptr_parameter("IVROverlay_016_ShowMessageOverlay", (void *)6);

    init_thunk(t, this_ptr_value, IVROverlay_016_CloseMessageOverlay, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_016_CloseMessageOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_016_CloseMessageOverlay();
    check_ptr_parameter("IVROverlay_016_CloseMessageOverlay", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_016(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_016_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_016_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_016_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_016_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetProjectionMatrix, 4, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_016_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_016_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_016_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_016_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_016_GetProjectionMatrix", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_016_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_016_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_016_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_016_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_016_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_016_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_016_ComputeDistortion, 4, TRUE, FALSE);
    bool (__stdcall *capi_IVRSystem_016_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
    check_ptr_parameter("IVRSystem_016_ComputeDistortion", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_016_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_016_ComputeDistortion", 3.0f);
    check_ptr_parameter("IVRSystem_016_ComputeDistortion", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_016_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_016_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_016_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_016_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_016_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_016_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_016_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_016_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_016_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetDXGIOutputInfo, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_016_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetDXGIOutputInfo((void *)1);
    check_ptr_parameter("IVRSystem_016_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_016_GetDXGIOutputInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetOutputDevice, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_016_GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetOutputDevice((void *)1, 2);
    check_ptr_parameter("IVRSystem_016_GetOutputDevice", this_ptr_value);
    check_ptr_parameter("IVRSystem_016_GetOutputDevice", (void *)1);
    check_uint32_parameter("IVRSystem_016_GetOutputDevice", 2);

    init_thunk(t, this_ptr_value, IVRSystem_016_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_016_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_016_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_016_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_016_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_016_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_016_SetDisplayVisibility", 1);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_016_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_016_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_016_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_016_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_016_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_016_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_016_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_016_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_016_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_016_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_016_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_016_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_016_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_016_ApplyTransform, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_016_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_ApplyTransform((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_016_ApplyTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_016_ApplyTransform", (void *)1);
    check_ptr_parameter("IVRSystem_016_ApplyTransform", (void *)2);
    check_ptr_parameter("IVRSystem_016_ApplyTransform", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_016_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetTrackedDeviceIndexForControllerRole(1);
    check_ptr_parameter("IVRSystem_016_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetTrackedDeviceIndexForControllerRole", 1);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
    ETrackedControllerRole (__stdcall *capi_IVRSystem_016_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetControllerRoleForTrackedDeviceIndex(1);
    check_ptr_parameter("IVRSystem_016_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetControllerRoleForTrackedDeviceIndex", 1);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetTrackedDeviceClass, 1, FALSE, FALSE);
    ETrackedDeviceClass (__stdcall *capi_IVRSystem_016_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_016_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_016_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_016_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_016_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_016_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_016_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_016_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_016_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_016_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_016_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_016_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_016_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_016_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_016_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_016_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_016_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_016_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_016_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_016_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_016_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_016_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_016_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_016_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_016_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_016_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_016_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_016_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_016_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_016_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_016_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_016_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_016_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_016_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_016_PollNextEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_016_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_PollNextEvent((void *)1, 2);
    check_ptr_parameter("IVRSystem_016_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_016_PollNextEvent", (void *)1);
    check_uint32_parameter("IVRSystem_016_PollNextEvent", 2);

    init_thunk(t, this_ptr_value, IVRSystem_016_PollNextEventWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_016_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSystem_016_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_016_PollNextEventWithPose", (void *)2);
    check_uint32_parameter("IVRSystem_016_PollNextEventWithPose", 3);
    check_ptr_parameter("IVRSystem_016_PollNextEventWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_016_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_016_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetHiddenAreaMesh, 3, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_016_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetHiddenAreaMesh(data_ptr_value, 1, 2);
    check_ptr_parameter("IVRSystem_016_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_016_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetHiddenAreaMesh", 1);
    check_uint32_parameter("IVRSystem_016_GetHiddenAreaMesh", 2);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetControllerState, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_016_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetControllerState(1, (void *)2, 3);
    check_ptr_parameter("IVRSystem_016_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_016_GetControllerState", (void *)2);
    check_uint32_parameter("IVRSystem_016_GetControllerState", 3);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetControllerStateWithPose, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_016_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_016_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_016_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_016_GetControllerStateWithPose", (void *)3);
    check_uint32_parameter("IVRSystem_016_GetControllerStateWithPose", 4);
    check_ptr_parameter("IVRSystem_016_GetControllerStateWithPose", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_016_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_016_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_016_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_016_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_016_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_016_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_016_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_016_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_016_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_016_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_016_CaptureInputFocus, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_016_CaptureInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_CaptureInputFocus();
    check_ptr_parameter("IVRSystem_016_CaptureInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_016_ReleaseInputFocus, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_016_ReleaseInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_ReleaseInputFocus();
    check_ptr_parameter("IVRSystem_016_ReleaseInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_016_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_016_IsInputFocusCapturedByAnotherProcess)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_IsInputFocusCapturedByAnotherProcess();
    check_ptr_parameter("IVRSystem_016_IsInputFocusCapturedByAnotherProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_016_DriverDebugRequest, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_016_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_DriverDebugRequest(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRSystem_016_DriverDebugRequest", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_DriverDebugRequest", 1);
    check_ptr_parameter("IVRSystem_016_DriverDebugRequest", (void *)2);
    check_ptr_parameter("IVRSystem_016_DriverDebugRequest", (void *)3);
    check_uint32_parameter("IVRSystem_016_DriverDebugRequest", 4);

    init_thunk(t, this_ptr_value, IVRSystem_016_PerformFirmwareUpdate, 1, FALSE, FALSE);
    EVRFirmwareError (__stdcall *capi_IVRSystem_016_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_016_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_016_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_016_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_016_AcknowledgeQuit_Exiting)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_AcknowledgeQuit_Exiting();
    check_ptr_parameter("IVRSystem_016_AcknowledgeQuit_Exiting", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_016_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_016_AcknowledgeQuit_UserPrompt)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_016_AcknowledgeQuit_UserPrompt();
    check_ptr_parameter("IVRSystem_016_AcknowledgeQuit_UserPrompt", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_020(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_020_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_020_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_020_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_020_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_020_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_020_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_020_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_020_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_020_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_020_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_020_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_020_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_020_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_020_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_020_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_020_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_020_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_020_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_020_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_020_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_020_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_020_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_020_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_020_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_020_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_020_Submit", 1);
    check_ptr_parameter("IVRCompositor_020_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_020_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_020_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_020_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_020_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_020_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_020_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_020_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_020_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_020_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetFrameTimings, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_020_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetFrameTimings((void *)1, 2);
    check_ptr_parameter("IVRCompositor_020_GetFrameTimings", this_ptr_value);
    check_ptr_parameter("IVRCompositor_020_GetFrameTimings", (void *)1);
    check_uint32_parameter("IVRCompositor_020_GetFrameTimings", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_020_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_020_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetCumulativeStats, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetCumulativeStats((void *)1, 2);
    check_ptr_parameter("IVRCompositor_020_GetCumulativeStats", this_ptr_value);
    check_ptr_parameter("IVRCompositor_020_GetCumulativeStats", (void *)1);
    check_uint32_parameter("IVRCompositor_020_GetCumulativeStats", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_020_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_020_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_020_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_020_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_020_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_020_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_020_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_020_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_020_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetCurrentFadeColor, 2, FALSE, FALSE);
    HmdColor_t *(__stdcall *capi_IVRCompositor_020_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetCurrentFadeColor(data_ptr_value, 1);
    check_ptr_parameter("IVRCompositor_020_GetCurrentFadeColor", this_ptr_value);
    check_ptr_parameter("IVRCompositor_020_GetCurrentFadeColor", data_ptr_value);
    check_bool_parameter("IVRCompositor_020_GetCurrentFadeColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_020_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_020_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_020_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_020_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetCurrentGridAlpha, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_020_GetCurrentGridAlpha)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetCurrentGridAlpha();
    check_ptr_parameter("IVRCompositor_020_GetCurrentGridAlpha", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_020_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_020_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_020_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_020_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_020_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_020_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_020_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_020_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_CompositorQuit();
    check_ptr_parameter("IVRCompositor_020_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_020_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_IsFullscreen();
    check_ptr_parameter("IVRCompositor_020_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_020_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_020_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_020_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_020_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_020_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_CanRenderScene();
    check_ptr_parameter("IVRCompositor_020_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_020_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_020_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_020_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_020_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_020_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_020_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_020_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_020_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_020_ForceInterleavedReprojectionOn", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_020_ForceReconnectProcess, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_ForceReconnectProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_ForceReconnectProcess();
    check_ptr_parameter("IVRCompositor_020_ForceReconnectProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_020_SuspendRendering, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_SuspendRendering)(bool bSuspend) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_SuspendRendering(1);
    check_ptr_parameter("IVRCompositor_020_SuspendRendering", this_ptr_value);
    check_bool_parameter("IVRCompositor_020_SuspendRendering", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetMirrorTextureD3D11, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_020_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_020_GetMirrorTextureD3D11", this_ptr_value);
    check_uint32_parameter("IVRCompositor_020_GetMirrorTextureD3D11", 1);
    check_ptr_parameter("IVRCompositor_020_GetMirrorTextureD3D11", (void *)2);
    check_ptr_parameter("IVRCompositor_020_GetMirrorTextureD3D11", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_020_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_ReleaseMirrorTextureD3D11((void *)1);
    check_ptr_parameter("IVRCompositor_020_ReleaseMirrorTextureD3D11", this_ptr_value);
    check_ptr_parameter("IVRCompositor_020_ReleaseMirrorTextureD3D11", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetMirrorTextureGL, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_020_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetMirrorTextureGL(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_020_GetMirrorTextureGL", this_ptr_value);
    check_uint32_parameter("IVRCompositor_020_GetMirrorTextureGL", 1);
    check_ptr_parameter("IVRCompositor_020_GetMirrorTextureGL", (void *)2);
    check_ptr_parameter("IVRCompositor_020_GetMirrorTextureGL", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_020_ReleaseSharedGLTexture, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_020_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_ReleaseSharedGLTexture(1, (void *)2);
    check_ptr_parameter("IVRCompositor_020_ReleaseSharedGLTexture", this_ptr_value);
    check_uint32_parameter("IVRCompositor_020_ReleaseSharedGLTexture", 1);
    check_ptr_parameter("IVRCompositor_020_ReleaseSharedGLTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_020_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_LockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_020_LockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_020_LockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_020_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_020_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_UnlockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_020_UnlockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_020_UnlockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_020_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetVulkanInstanceExtensionsRequired((void *)1, 2);
    check_ptr_parameter("IVRCompositor_020_GetVulkanInstanceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_020_GetVulkanInstanceExtensionsRequired", (void *)1);
    check_uint32_parameter("IVRCompositor_020_GetVulkanInstanceExtensionsRequired", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_020_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_020_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_020_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRCompositor_020_GetVulkanDeviceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_020_GetVulkanDeviceExtensionsRequired", (void *)1);
    check_ptr_parameter("IVRCompositor_020_GetVulkanDeviceExtensionsRequired", (void *)2);
    check_uint32_parameter("IVRCompositor_020_GetVulkanDeviceExtensionsRequired", 3);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRClientCore_002(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRClientCore_002_Init, 1, FALSE, FALSE);
    EVRInitError (__stdcall *capi_IVRClientCore_002_Init)(EVRApplicationType eApplicationType) = (void *)t;

    clear_parameters();
    capi_IVRClientCore_002_Init(1);
    check_ptr_parameter("IVRClientCore_002_Init", this_ptr_value);
    check_uint32_parameter("IVRClientCore_002_Init", 1);

    init_thunk(t, this_ptr_value, IVRClientCore_002_Cleanup, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRClientCore_002_Cleanup)() = (void *)t;

    clear_parameters();
    capi_IVRClientCore_002_Cleanup();
    check_ptr_parameter("IVRClientCore_002_Cleanup", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRClientCore_002_IsInterfaceVersionValid, 1, FALSE, FALSE);
    EVRInitError (__stdcall *capi_IVRClientCore_002_IsInterfaceVersionValid)(const char * pchInterfaceVersion) = (void *)t;

    clear_parameters();
    capi_IVRClientCore_002_IsInterfaceVersionValid((void *)1);
    check_ptr_parameter("IVRClientCore_002_IsInterfaceVersionValid", this_ptr_value);
    check_ptr_parameter("IVRClientCore_002_IsInterfaceVersionValid", (void *)1);

    init_thunk(t, this_ptr_value, IVRClientCore_002_GetGenericInterface, 2, FALSE, FALSE);
    void * (__stdcall *capi_IVRClientCore_002_GetGenericInterface)(const char * pchNameAndVersion, EVRInitError * peError) = (void *)t;

    clear_parameters();
    capi_IVRClientCore_002_GetGenericInterface((void *)1, (void *)2);
    check_ptr_parameter("IVRClientCore_002_GetGenericInterface", this_ptr_value);
    check_ptr_parameter("IVRClientCore_002_GetGenericInterface", (void *)1);
    check_ptr_parameter("IVRClientCore_002_GetGenericInterface", (void *)2);

    init_thunk(t, this_ptr_value, IVRClientCore_002_BIsHmdPresent, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRClientCore_002_BIsHmdPresent)() = (void *)t;

    clear_parameters();
    capi_IVRClientCore_002_BIsHmdPresent();
    check_ptr_parameter("IVRClientCore_002_BIsHmdPresent", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRClientCore_002_GetEnglishStringForHmdError, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRClientCore_002_GetEnglishStringForHmdError)(EVRInitError eError) = (void *)t;

    clear_parameters();
    capi_IVRClientCore_002_GetEnglishStringForHmdError(1);
    check_ptr_parameter("IVRClientCore_002_GetEnglishStringForHmdError", this_ptr_value);
    check_uint32_parameter("IVRClientCore_002_GetEnglishStringForHmdError", 1);

    init_thunk(t, this_ptr_value, IVRClientCore_002_GetIDForVRInitError, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRClientCore_002_GetIDForVRInitError)(EVRInitError eError) = (void *)t;

    clear_parameters();
    capi_IVRClientCore_002_GetIDForVRInitError(1);
    check_ptr_parameter("IVRClientCore_002_GetIDForVRInitError", this_ptr_value);
    check_uint32_parameter("IVRClientCore_002_GetIDForVRInitError", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_015(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_015_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_015_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_015_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_015_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetProjectionMatrix, 4, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_015_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_015_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_015_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_015_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_015_GetProjectionMatrix", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_015_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_015_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_015_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_015_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_015_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_015_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_015_ComputeDistortion, 4, TRUE, FALSE);
    bool (__stdcall *capi_IVRSystem_015_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
    check_ptr_parameter("IVRSystem_015_ComputeDistortion", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_015_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_015_ComputeDistortion", 3.0f);
    check_ptr_parameter("IVRSystem_015_ComputeDistortion", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_015_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_015_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_015_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_015_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_015_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_015_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_015_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_015_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_015_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetDXGIOutputInfo, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_015_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetDXGIOutputInfo((void *)1);
    check_ptr_parameter("IVRSystem_015_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_015_GetDXGIOutputInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_015_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_015_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_015_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_015_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_015_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_015_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_015_SetDisplayVisibility", 1);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_015_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_015_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_015_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_015_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_015_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_015_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_015_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_015_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_015_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_015_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_015_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_015_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_015_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_015_ApplyTransform, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_015_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_ApplyTransform((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_015_ApplyTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_015_ApplyTransform", (void *)1);
    check_ptr_parameter("IVRSystem_015_ApplyTransform", (void *)2);
    check_ptr_parameter("IVRSystem_015_ApplyTransform", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_015_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetTrackedDeviceIndexForControllerRole(1);
    check_ptr_parameter("IVRSystem_015_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetTrackedDeviceIndexForControllerRole", 1);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
    ETrackedControllerRole (__stdcall *capi_IVRSystem_015_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetControllerRoleForTrackedDeviceIndex(1);
    check_ptr_parameter("IVRSystem_015_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetControllerRoleForTrackedDeviceIndex", 1);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetTrackedDeviceClass, 1, FALSE, FALSE);
    ETrackedDeviceClass (__stdcall *capi_IVRSystem_015_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_015_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_015_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_015_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_015_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_015_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_015_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_015_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_015_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_015_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_015_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_015_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_015_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_015_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_015_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_015_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_015_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_015_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_015_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_015_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_015_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_015_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_015_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_015_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_015_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_015_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_015_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_015_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_015_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_015_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_015_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_015_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_015_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_015_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_015_PollNextEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_015_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_PollNextEvent((void *)1, 2);
    check_ptr_parameter("IVRSystem_015_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_015_PollNextEvent", (void *)1);
    check_uint32_parameter("IVRSystem_015_PollNextEvent", 2);

    init_thunk(t, this_ptr_value, IVRSystem_015_PollNextEventWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_015_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSystem_015_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_015_PollNextEventWithPose", (void *)2);
    check_uint32_parameter("IVRSystem_015_PollNextEventWithPose", 3);
    check_ptr_parameter("IVRSystem_015_PollNextEventWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_015_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_015_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetHiddenAreaMesh, 3, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_015_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetHiddenAreaMesh(data_ptr_value, 1, 2);
    check_ptr_parameter("IVRSystem_015_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_015_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetHiddenAreaMesh", 1);
    check_uint32_parameter("IVRSystem_015_GetHiddenAreaMesh", 2);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetControllerState, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_015_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetControllerState(1, (void *)2, 3);
    check_ptr_parameter("IVRSystem_015_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_015_GetControllerState", (void *)2);
    check_uint32_parameter("IVRSystem_015_GetControllerState", 3);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetControllerStateWithPose, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_015_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_015_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_015_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_015_GetControllerStateWithPose", (void *)3);
    check_uint32_parameter("IVRSystem_015_GetControllerStateWithPose", 4);
    check_ptr_parameter("IVRSystem_015_GetControllerStateWithPose", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_015_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_015_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_015_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_015_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_015_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_015_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_015_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_015_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_015_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_015_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_015_CaptureInputFocus, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_015_CaptureInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_CaptureInputFocus();
    check_ptr_parameter("IVRSystem_015_CaptureInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_015_ReleaseInputFocus, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_015_ReleaseInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_ReleaseInputFocus();
    check_ptr_parameter("IVRSystem_015_ReleaseInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_015_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_015_IsInputFocusCapturedByAnotherProcess)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_IsInputFocusCapturedByAnotherProcess();
    check_ptr_parameter("IVRSystem_015_IsInputFocusCapturedByAnotherProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_015_DriverDebugRequest, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_015_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_DriverDebugRequest(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRSystem_015_DriverDebugRequest", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_DriverDebugRequest", 1);
    check_ptr_parameter("IVRSystem_015_DriverDebugRequest", (void *)2);
    check_ptr_parameter("IVRSystem_015_DriverDebugRequest", (void *)3);
    check_uint32_parameter("IVRSystem_015_DriverDebugRequest", 4);

    init_thunk(t, this_ptr_value, IVRSystem_015_PerformFirmwareUpdate, 1, FALSE, FALSE);
    EVRFirmwareError (__stdcall *capi_IVRSystem_015_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_015_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_015_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_015_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_015_AcknowledgeQuit_Exiting)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_AcknowledgeQuit_Exiting();
    check_ptr_parameter("IVRSystem_015_AcknowledgeQuit_Exiting", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_015_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_015_AcknowledgeQuit_UserPrompt)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_015_AcknowledgeQuit_UserPrompt();
    check_ptr_parameter("IVRSystem_015_AcknowledgeQuit_UserPrompt", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_014(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_014_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_014_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_014_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_014_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_014_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_014_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_014_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_014_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_014_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_014_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetHighQualityOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_014_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_014_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_014_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_014_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_014_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_014_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_014_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_014_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_014_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_014_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_014_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_014_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_014_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_014_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_014_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_014_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_014_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_014_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_014_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_014_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_014_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_014_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_014_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_014_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_014_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_014_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_014_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_014_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_014_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_014_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_014_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_014_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_014_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_014_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_014_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_014_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTexelAspect, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayTexelAspect(1, 2.0f);
    check_ptr_parameter("IVROverlay_014_SetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayTexelAspect", 1);
    check_float_parameter("IVROverlay_014_SetOverlayTexelAspect", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTexelAspect, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayTexelAspect(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayTexelAspect", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayTexelAspect", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlaySortOrder(1, 2);
    check_ptr_parameter("IVROverlay_014_SetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlaySortOrder", 1);
    check_uint32_parameter("IVROverlay_014_SetOverlaySortOrder", 2);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlaySortOrder(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlaySortOrder", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlaySortOrder", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_014_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_014_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_014_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_014_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_014_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_014_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_014_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_014_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_014_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_014_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_014_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_014_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_014_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_014_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_014_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_HideOverlay(1);
    check_ptr_parameter("IVROverlay_014_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_014_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_014_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_014_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_014_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_014_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_014_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_014_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_014_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_014_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_014_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_014_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_014_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_014_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_014_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_014_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_014_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_014_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_014_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_014_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_014_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_014_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_014_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_014_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_014_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_014_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_014_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetGamepadFocusOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_014_GetGamepadFocusOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetGamepadFocusOverlay();
    check_ptr_parameter("IVROverlay_014_GetGamepadFocusOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetGamepadFocusOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetGamepadFocusOverlay(1);
    check_ptr_parameter("IVROverlay_014_SetGamepadFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetGamepadFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayNeighbor, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayNeighbor(1, 2, 3);
    check_ptr_parameter("IVROverlay_014_SetOverlayNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_014_SetOverlayNeighbor", 1);
    check_uint64_parameter("IVROverlay_014_SetOverlayNeighbor", 2);
    check_uint64_parameter("IVROverlay_014_SetOverlayNeighbor", 3);

    init_thunk(t, this_ptr_value, IVROverlay_014_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_MoveGamepadFocusToNeighbor(1, 2);
    check_ptr_parameter("IVROverlay_014_MoveGamepadFocusToNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_014_MoveGamepadFocusToNeighbor", 1);
    check_uint64_parameter("IVROverlay_014_MoveGamepadFocusToNeighbor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_014_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_014_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_014_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_014_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_014_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_014_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_014_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_014_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTexture, 9, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)8);
    check_ptr_parameter("IVROverlay_014_GetOverlayTexture", (void *)9);

    init_thunk(t, this_ptr_value, IVROverlay_014_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_014_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayTextureSize, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayTextureSize(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_014_GetOverlayTextureSize", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayTextureSize", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayTextureSize", (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayTextureSize", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_014_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_014_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_014_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_014_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_014_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_014_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_014_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_014_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_014_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_014_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_014_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_014_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_014_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_014_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_014_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_014_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_014_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_014_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_014_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_014_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_014_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_014_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_014_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_014_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_014_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_014_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_014_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_014_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_014_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_014_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_014_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_014_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_014_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_014_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_014_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_014_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_014_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_014_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_014_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_014_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_014_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_014_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_014_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_014_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_HideKeyboard();
    check_ptr_parameter("IVROverlay_014_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_014_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_014_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_014_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_014_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_014_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_014_SetKeyboardPositionForOverlay", DEFAULT_RECT);

    init_thunk(t, this_ptr_value, IVROverlay_014_SetOverlayIntersectionMask, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
    check_ptr_parameter("IVROverlay_014_SetOverlayIntersectionMask", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_SetOverlayIntersectionMask", 1);
    check_ptr_parameter("IVROverlay_014_SetOverlayIntersectionMask", (void *)2);
    check_uint32_parameter("IVROverlay_014_SetOverlayIntersectionMask", 3);
    check_uint32_parameter("IVROverlay_014_SetOverlayIntersectionMask", 4);

    init_thunk(t, this_ptr_value, IVROverlay_014_GetOverlayFlags, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_014_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_GetOverlayFlags(1, (void *)2);
    check_ptr_parameter("IVROverlay_014_GetOverlayFlags", this_ptr_value);
    check_uint64_parameter("IVROverlay_014_GetOverlayFlags", 1);
    check_ptr_parameter("IVROverlay_014_GetOverlayFlags", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_014_ShowMessageOverlay, 6, FALSE, FALSE);
    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_014_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;

    clear_parameters();
    capi_IVROverlay_014_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", (void *)4);
    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", (void *)5);
    check_ptr_parameter("IVROverlay_014_ShowMessageOverlay", (void *)6);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_019(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_019_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_019_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_019_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_019_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_019_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_019_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_019_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_019_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_019_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_019_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_019_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_019_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_019_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_019_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_019_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_019_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_019_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_019_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_019_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_019_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_019_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_019_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_019_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_019_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_019_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_019_Submit", 1);
    check_ptr_parameter("IVRCompositor_019_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_019_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_019_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_019_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_019_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_019_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_019_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_019_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_019_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_019_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetFrameTimings, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_019_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetFrameTimings((void *)1, 2);
    check_ptr_parameter("IVRCompositor_019_GetFrameTimings", this_ptr_value);
    check_ptr_parameter("IVRCompositor_019_GetFrameTimings", (void *)1);
    check_uint32_parameter("IVRCompositor_019_GetFrameTimings", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_019_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_019_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetCumulativeStats, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetCumulativeStats((void *)1, 2);
    check_ptr_parameter("IVRCompositor_019_GetCumulativeStats", this_ptr_value);
    check_ptr_parameter("IVRCompositor_019_GetCumulativeStats", (void *)1);
    check_uint32_parameter("IVRCompositor_019_GetCumulativeStats", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_019_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_019_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_019_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_019_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_019_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_019_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_019_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_019_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_019_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetCurrentFadeColor, 2, FALSE, FALSE);
    HmdColor_t *(__stdcall *capi_IVRCompositor_019_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetCurrentFadeColor(data_ptr_value, 1);
    check_ptr_parameter("IVRCompositor_019_GetCurrentFadeColor", this_ptr_value);
    check_ptr_parameter("IVRCompositor_019_GetCurrentFadeColor", data_ptr_value);
    check_bool_parameter("IVRCompositor_019_GetCurrentFadeColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_019_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_019_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_019_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_019_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetCurrentGridAlpha, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_019_GetCurrentGridAlpha)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetCurrentGridAlpha();
    check_ptr_parameter("IVRCompositor_019_GetCurrentGridAlpha", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_019_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_019_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_019_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_019_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_019_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_019_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_019_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_019_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_CompositorQuit();
    check_ptr_parameter("IVRCompositor_019_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_019_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_IsFullscreen();
    check_ptr_parameter("IVRCompositor_019_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_019_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_019_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_019_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_019_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_019_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_CanRenderScene();
    check_ptr_parameter("IVRCompositor_019_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_019_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_019_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_019_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_019_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_019_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_019_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_019_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_019_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_019_ForceInterleavedReprojectionOn", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_019_ForceReconnectProcess, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_ForceReconnectProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_ForceReconnectProcess();
    check_ptr_parameter("IVRCompositor_019_ForceReconnectProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_019_SuspendRendering, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_SuspendRendering)(bool bSuspend) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_SuspendRendering(1);
    check_ptr_parameter("IVRCompositor_019_SuspendRendering", this_ptr_value);
    check_bool_parameter("IVRCompositor_019_SuspendRendering", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetMirrorTextureD3D11, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_019_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_019_GetMirrorTextureD3D11", this_ptr_value);
    check_uint32_parameter("IVRCompositor_019_GetMirrorTextureD3D11", 1);
    check_ptr_parameter("IVRCompositor_019_GetMirrorTextureD3D11", (void *)2);
    check_ptr_parameter("IVRCompositor_019_GetMirrorTextureD3D11", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetMirrorTextureGL, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_019_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetMirrorTextureGL(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_019_GetMirrorTextureGL", this_ptr_value);
    check_uint32_parameter("IVRCompositor_019_GetMirrorTextureGL", 1);
    check_ptr_parameter("IVRCompositor_019_GetMirrorTextureGL", (void *)2);
    check_ptr_parameter("IVRCompositor_019_GetMirrorTextureGL", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_019_ReleaseSharedGLTexture, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_019_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_ReleaseSharedGLTexture(1, (void *)2);
    check_ptr_parameter("IVRCompositor_019_ReleaseSharedGLTexture", this_ptr_value);
    check_uint32_parameter("IVRCompositor_019_ReleaseSharedGLTexture", 1);
    check_ptr_parameter("IVRCompositor_019_ReleaseSharedGLTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_019_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_LockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_019_LockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_019_LockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_019_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_019_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_UnlockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_019_UnlockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_019_UnlockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_019_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetVulkanInstanceExtensionsRequired((void *)1, 2);
    check_ptr_parameter("IVRCompositor_019_GetVulkanInstanceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_019_GetVulkanInstanceExtensionsRequired", (void *)1);
    check_uint32_parameter("IVRCompositor_019_GetVulkanInstanceExtensionsRequired", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_019_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_019_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_019_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
    check_ptr_parameter("IVRCompositor_019_GetVulkanDeviceExtensionsRequired", this_ptr_value);
    check_ptr_parameter("IVRCompositor_019_GetVulkanDeviceExtensionsRequired", (void *)1);
    check_ptr_parameter("IVRCompositor_019_GetVulkanDeviceExtensionsRequired", (void *)2);
    check_uint32_parameter("IVRCompositor_019_GetVulkanDeviceExtensionsRequired", 3);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_014(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_014_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_014_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_014_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_014_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetProjectionMatrix, 5, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_014_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
    check_ptr_parameter("IVRSystem_014_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_014_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_014_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_014_GetProjectionMatrix", 3.0f);
    check_uint32_parameter("IVRSystem_014_GetProjectionMatrix", 4);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_014_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_014_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_014_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_014_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_014_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_014_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_014_ComputeDistortion, 4, TRUE, FALSE);
    bool (__stdcall *capi_IVRSystem_014_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
    check_ptr_parameter("IVRSystem_014_ComputeDistortion", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_014_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_014_ComputeDistortion", 3.0f);
    check_ptr_parameter("IVRSystem_014_ComputeDistortion", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_014_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_014_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_014_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_014_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_014_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_014_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_014_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_014_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_014_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetDXGIOutputInfo, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_014_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetDXGIOutputInfo((void *)1);
    check_ptr_parameter("IVRSystem_014_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_014_GetDXGIOutputInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_014_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_014_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_014_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_014_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_014_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_014_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_014_SetDisplayVisibility", 1);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_014_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_014_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_014_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_014_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_014_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_014_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_014_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_014_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_014_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_014_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_014_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_014_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_014_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_014_ApplyTransform, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_014_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_ApplyTransform((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_014_ApplyTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_014_ApplyTransform", (void *)1);
    check_ptr_parameter("IVRSystem_014_ApplyTransform", (void *)2);
    check_ptr_parameter("IVRSystem_014_ApplyTransform", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_014_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetTrackedDeviceIndexForControllerRole(1);
    check_ptr_parameter("IVRSystem_014_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetTrackedDeviceIndexForControllerRole", 1);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
    ETrackedControllerRole (__stdcall *capi_IVRSystem_014_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetControllerRoleForTrackedDeviceIndex(1);
    check_ptr_parameter("IVRSystem_014_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetControllerRoleForTrackedDeviceIndex", 1);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetTrackedDeviceClass, 1, FALSE, FALSE);
    ETrackedDeviceClass (__stdcall *capi_IVRSystem_014_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_014_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_014_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_014_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_014_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_014_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_014_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_014_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_014_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_014_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_014_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_014_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_014_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_014_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_014_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_014_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_014_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_014_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_014_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_014_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_014_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_014_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_014_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_014_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_014_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_014_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_014_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_014_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_014_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_014_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_014_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_014_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_014_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_014_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_014_PollNextEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_014_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_PollNextEvent((void *)1, 2);
    check_ptr_parameter("IVRSystem_014_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_014_PollNextEvent", (void *)1);
    check_uint32_parameter("IVRSystem_014_PollNextEvent", 2);

    init_thunk(t, this_ptr_value, IVRSystem_014_PollNextEventWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_014_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSystem_014_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_014_PollNextEventWithPose", (void *)2);
    check_uint32_parameter("IVRSystem_014_PollNextEventWithPose", 3);
    check_ptr_parameter("IVRSystem_014_PollNextEventWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_014_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_014_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetHiddenAreaMesh, 3, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_014_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetHiddenAreaMesh(data_ptr_value, 1, 2);
    check_ptr_parameter("IVRSystem_014_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_014_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetHiddenAreaMesh", 1);
    check_uint32_parameter("IVRSystem_014_GetHiddenAreaMesh", 2);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetControllerState, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_014_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetControllerState(1, (void *)2, 3);
    check_ptr_parameter("IVRSystem_014_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_014_GetControllerState", (void *)2);
    check_uint32_parameter("IVRSystem_014_GetControllerState", 3);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetControllerStateWithPose, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_014_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_014_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_014_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_014_GetControllerStateWithPose", (void *)3);
    check_uint32_parameter("IVRSystem_014_GetControllerStateWithPose", 4);
    check_ptr_parameter("IVRSystem_014_GetControllerStateWithPose", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_014_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_014_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_014_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_014_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_014_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_014_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_014_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_014_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_014_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_014_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_014_CaptureInputFocus, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_014_CaptureInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_CaptureInputFocus();
    check_ptr_parameter("IVRSystem_014_CaptureInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_014_ReleaseInputFocus, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_014_ReleaseInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_ReleaseInputFocus();
    check_ptr_parameter("IVRSystem_014_ReleaseInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_014_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_014_IsInputFocusCapturedByAnotherProcess)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_IsInputFocusCapturedByAnotherProcess();
    check_ptr_parameter("IVRSystem_014_IsInputFocusCapturedByAnotherProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_014_DriverDebugRequest, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_014_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_DriverDebugRequest(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRSystem_014_DriverDebugRequest", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_DriverDebugRequest", 1);
    check_ptr_parameter("IVRSystem_014_DriverDebugRequest", (void *)2);
    check_ptr_parameter("IVRSystem_014_DriverDebugRequest", (void *)3);
    check_uint32_parameter("IVRSystem_014_DriverDebugRequest", 4);

    init_thunk(t, this_ptr_value, IVRSystem_014_PerformFirmwareUpdate, 1, FALSE, FALSE);
    EVRFirmwareError (__stdcall *capi_IVRSystem_014_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_014_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_014_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_014_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_014_AcknowledgeQuit_Exiting)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_AcknowledgeQuit_Exiting();
    check_ptr_parameter("IVRSystem_014_AcknowledgeQuit_Exiting", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_014_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_014_AcknowledgeQuit_UserPrompt)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_014_AcknowledgeQuit_UserPrompt();
    check_ptr_parameter("IVRSystem_014_AcknowledgeQuit_UserPrompt", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_018(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_018_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_018_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_018_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_018_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_018_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_018_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_018_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_018_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_018_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_018_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_018_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_018_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_018_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_018_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_018_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_018_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_018_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_018_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_018_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_018_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_018_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_018_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_018_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_018_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_018_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_018_Submit", 1);
    check_ptr_parameter("IVRCompositor_018_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_018_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_018_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_018_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_018_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_018_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_018_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_018_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_018_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_018_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetFrameTimings, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_018_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetFrameTimings((void *)1, 2);
    check_ptr_parameter("IVRCompositor_018_GetFrameTimings", this_ptr_value);
    check_ptr_parameter("IVRCompositor_018_GetFrameTimings", (void *)1);
    check_uint32_parameter("IVRCompositor_018_GetFrameTimings", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_018_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_018_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetCumulativeStats, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetCumulativeStats((void *)1, 2);
    check_ptr_parameter("IVRCompositor_018_GetCumulativeStats", this_ptr_value);
    check_ptr_parameter("IVRCompositor_018_GetCumulativeStats", (void *)1);
    check_uint32_parameter("IVRCompositor_018_GetCumulativeStats", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_018_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_018_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_018_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_018_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_018_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_018_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_018_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_018_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_018_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetCurrentFadeColor, 2, FALSE, FALSE);
    HmdColor_t *(__stdcall *capi_IVRCompositor_018_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetCurrentFadeColor(data_ptr_value, 1);
    check_ptr_parameter("IVRCompositor_018_GetCurrentFadeColor", this_ptr_value);
    check_ptr_parameter("IVRCompositor_018_GetCurrentFadeColor", data_ptr_value);
    check_bool_parameter("IVRCompositor_018_GetCurrentFadeColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_018_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_018_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_018_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_018_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetCurrentGridAlpha, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_018_GetCurrentGridAlpha)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetCurrentGridAlpha();
    check_ptr_parameter("IVRCompositor_018_GetCurrentGridAlpha", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_018_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_018_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_018_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_018_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_018_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_018_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_018_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_018_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_CompositorQuit();
    check_ptr_parameter("IVRCompositor_018_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_018_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_IsFullscreen();
    check_ptr_parameter("IVRCompositor_018_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_018_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_018_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_018_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_018_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_018_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_CanRenderScene();
    check_ptr_parameter("IVRCompositor_018_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_018_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_018_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_018_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_018_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_018_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_018_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_018_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_018_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_018_ForceInterleavedReprojectionOn", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_018_ForceReconnectProcess, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_ForceReconnectProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_ForceReconnectProcess();
    check_ptr_parameter("IVRCompositor_018_ForceReconnectProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_018_SuspendRendering, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_SuspendRendering)(bool bSuspend) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_SuspendRendering(1);
    check_ptr_parameter("IVRCompositor_018_SuspendRendering", this_ptr_value);
    check_bool_parameter("IVRCompositor_018_SuspendRendering", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetMirrorTextureD3D11, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_018_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_018_GetMirrorTextureD3D11", this_ptr_value);
    check_uint32_parameter("IVRCompositor_018_GetMirrorTextureD3D11", 1);
    check_ptr_parameter("IVRCompositor_018_GetMirrorTextureD3D11", (void *)2);
    check_ptr_parameter("IVRCompositor_018_GetMirrorTextureD3D11", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_018_GetMirrorTextureGL, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_018_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_GetMirrorTextureGL(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_018_GetMirrorTextureGL", this_ptr_value);
    check_uint32_parameter("IVRCompositor_018_GetMirrorTextureGL", 1);
    check_ptr_parameter("IVRCompositor_018_GetMirrorTextureGL", (void *)2);
    check_ptr_parameter("IVRCompositor_018_GetMirrorTextureGL", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_018_ReleaseSharedGLTexture, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_018_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_ReleaseSharedGLTexture(1, (void *)2);
    check_ptr_parameter("IVRCompositor_018_ReleaseSharedGLTexture", this_ptr_value);
    check_uint32_parameter("IVRCompositor_018_ReleaseSharedGLTexture", 1);
    check_ptr_parameter("IVRCompositor_018_ReleaseSharedGLTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_018_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_LockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_018_LockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_018_LockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_018_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_018_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_018_UnlockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_018_UnlockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_018_UnlockGLSharedTextureForAccess", (void *)1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_013(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_013_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_013_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_013_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_013_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_013_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_013_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_013_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_013_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_013_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_013_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetHighQualityOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_013_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_013_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_013_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_013_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_013_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_013_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_013_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_013_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_013_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_013_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_013_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_013_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_013_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_013_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_013_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_013_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_013_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_013_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_013_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_013_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_013_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_013_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_013_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_013_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_013_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_013_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_013_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_013_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_013_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_013_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_013_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_013_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_013_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_013_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_013_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_013_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTexelAspect, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayTexelAspect(1, 2.0f);
    check_ptr_parameter("IVROverlay_013_SetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayTexelAspect", 1);
    check_float_parameter("IVROverlay_013_SetOverlayTexelAspect", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTexelAspect, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayTexelAspect(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayTexelAspect", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayTexelAspect", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayTexelAspect", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlaySortOrder(1, 2);
    check_ptr_parameter("IVROverlay_013_SetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlaySortOrder", 1);
    check_uint32_parameter("IVROverlay_013_SetOverlaySortOrder", 2);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlaySortOrder, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlaySortOrder(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlaySortOrder", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlaySortOrder", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlaySortOrder", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_013_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_013_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_013_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_013_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_013_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_013_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_013_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_013_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_013_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_013_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_013_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_013_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_013_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_013_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_013_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_HideOverlay(1);
    check_ptr_parameter("IVROverlay_013_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_013_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_013_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_013_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_013_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_013_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_013_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_013_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_013_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_013_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_013_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_013_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_013_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_013_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_013_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_013_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_013_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_013_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_013_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_013_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_013_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_013_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_013_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_013_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_013_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_013_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_013_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetGamepadFocusOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_013_GetGamepadFocusOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetGamepadFocusOverlay();
    check_ptr_parameter("IVROverlay_013_GetGamepadFocusOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetGamepadFocusOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetGamepadFocusOverlay(1);
    check_ptr_parameter("IVROverlay_013_SetGamepadFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetGamepadFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayNeighbor, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayNeighbor(1, 2, 3);
    check_ptr_parameter("IVROverlay_013_SetOverlayNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_013_SetOverlayNeighbor", 1);
    check_uint64_parameter("IVROverlay_013_SetOverlayNeighbor", 2);
    check_uint64_parameter("IVROverlay_013_SetOverlayNeighbor", 3);

    init_thunk(t, this_ptr_value, IVROverlay_013_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_MoveGamepadFocusToNeighbor(1, 2);
    check_ptr_parameter("IVROverlay_013_MoveGamepadFocusToNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_013_MoveGamepadFocusToNeighbor", 1);
    check_uint64_parameter("IVROverlay_013_MoveGamepadFocusToNeighbor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_013_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_013_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_013_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_013_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_013_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_013_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_013_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_013_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTexture, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8);
    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_013_GetOverlayTexture", (void *)8);

    init_thunk(t, this_ptr_value, IVROverlay_013_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_013_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetOverlayTextureSize, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetOverlayTextureSize(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_013_GetOverlayTextureSize", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetOverlayTextureSize", 1);
    check_ptr_parameter("IVROverlay_013_GetOverlayTextureSize", (void *)2);
    check_ptr_parameter("IVROverlay_013_GetOverlayTextureSize", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_013_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_013_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_013_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_013_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_013_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_013_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_013_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_013_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_013_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_013_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_013_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_013_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_013_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_013_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_013_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_013_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_013_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_013_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_013_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_013_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_013_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_013_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_013_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_013_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_013_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_013_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_013_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_013_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_013_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_013_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_013_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_013_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_013_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_013_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_013_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_013_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_013_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_013_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_013_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_013_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_013_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_013_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_013_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_013_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_013_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_HideKeyboard();
    check_ptr_parameter("IVROverlay_013_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_013_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_013_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_013_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_013_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_013_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_013_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_013_SetKeyboardPositionForOverlay", DEFAULT_RECT);

    init_thunk(t, this_ptr_value, IVROverlay_013_SetOverlayIntersectionMask, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_013_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_013_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
    check_ptr_parameter("IVROverlay_013_SetOverlayIntersectionMask", this_ptr_value);
    check_uint64_parameter("IVROverlay_013_SetOverlayIntersectionMask", 1);
    check_ptr_parameter("IVROverlay_013_SetOverlayIntersectionMask", (void *)2);
    check_uint32_parameter("IVROverlay_013_SetOverlayIntersectionMask", 3);
    check_uint32_parameter("IVROverlay_013_SetOverlayIntersectionMask", 4);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_017(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_017_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_017_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_017_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_017_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_017_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_017_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_017_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_017_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_017_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_017_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_017_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_017_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_017_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_017_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_017_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_017_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_017_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_017_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_017_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_017_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_017_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_017_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_017_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_017_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_017_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_017_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_017_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_017_Submit", 1);
    check_ptr_parameter("IVRCompositor_017_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_017_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_017_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_017_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_017_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_017_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_017_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_017_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_017_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_017_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_017_GetFrameTimings, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_017_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_GetFrameTimings((void *)1, 2);
    check_ptr_parameter("IVRCompositor_017_GetFrameTimings", this_ptr_value);
    check_ptr_parameter("IVRCompositor_017_GetFrameTimings", (void *)1);
    check_uint32_parameter("IVRCompositor_017_GetFrameTimings", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_017_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_017_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_017_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_GetCumulativeStats, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_GetCumulativeStats((void *)1, 2);
    check_ptr_parameter("IVRCompositor_017_GetCumulativeStats", this_ptr_value);
    check_ptr_parameter("IVRCompositor_017_GetCumulativeStats", (void *)1);
    check_uint32_parameter("IVRCompositor_017_GetCumulativeStats", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_017_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_017_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_017_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_017_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_017_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_017_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_017_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_017_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_017_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_017_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_017_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_017_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_017_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_017_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_017_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_017_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_017_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_017_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_017_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_017_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_017_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_017_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_CompositorQuit();
    check_ptr_parameter("IVRCompositor_017_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_017_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_IsFullscreen();
    check_ptr_parameter("IVRCompositor_017_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_017_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_017_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_017_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_017_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_017_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_CanRenderScene();
    check_ptr_parameter("IVRCompositor_017_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_017_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_017_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_017_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_017_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_017_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_017_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_017_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_017_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_017_ForceInterleavedReprojectionOn", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_017_ForceReconnectProcess, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_ForceReconnectProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_ForceReconnectProcess();
    check_ptr_parameter("IVRCompositor_017_ForceReconnectProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_017_SuspendRendering, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_SuspendRendering)(bool bSuspend) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_SuspendRendering(1);
    check_ptr_parameter("IVRCompositor_017_SuspendRendering", this_ptr_value);
    check_bool_parameter("IVRCompositor_017_SuspendRendering", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_017_GetMirrorTextureD3D11, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_017_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_017_GetMirrorTextureD3D11", this_ptr_value);
    check_uint32_parameter("IVRCompositor_017_GetMirrorTextureD3D11", 1);
    check_ptr_parameter("IVRCompositor_017_GetMirrorTextureD3D11", (void *)2);
    check_ptr_parameter("IVRCompositor_017_GetMirrorTextureD3D11", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_017_GetMirrorTextureGL, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_017_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_GetMirrorTextureGL(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_017_GetMirrorTextureGL", this_ptr_value);
    check_uint32_parameter("IVRCompositor_017_GetMirrorTextureGL", 1);
    check_ptr_parameter("IVRCompositor_017_GetMirrorTextureGL", (void *)2);
    check_ptr_parameter("IVRCompositor_017_GetMirrorTextureGL", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_017_ReleaseSharedGLTexture, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_017_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_ReleaseSharedGLTexture(1, (void *)2);
    check_ptr_parameter("IVRCompositor_017_ReleaseSharedGLTexture", this_ptr_value);
    check_uint32_parameter("IVRCompositor_017_ReleaseSharedGLTexture", 1);
    check_ptr_parameter("IVRCompositor_017_ReleaseSharedGLTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_017_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_LockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_017_LockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_017_LockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_017_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_017_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_017_UnlockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_017_UnlockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_017_UnlockGLSharedTextureForAccess", (void *)1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_012(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_012_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_012_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_012_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_012_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetProjectionMatrix, 5, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_012_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
    check_ptr_parameter("IVRSystem_012_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_012_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_012_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_012_GetProjectionMatrix", 3.0f);
    check_uint32_parameter("IVRSystem_012_GetProjectionMatrix", 4);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_012_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_012_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_012_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_012_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_012_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_012_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_012_ComputeDistortion, 4, TRUE, TRUE);
    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_012_ComputeDistortion)(DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_012_ComputeDistortion", this_ptr_value);
    check_ptr_parameter("IVRSystem_012_ComputeDistortion", data_ptr_value);
    check_uint32_parameter("IVRSystem_012_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_012_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_012_ComputeDistortion", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_012_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_012_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_012_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_012_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_012_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_012_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_012_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_012_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_012_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetDXGIOutputInfo, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_012_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetDXGIOutputInfo((void *)1);
    check_ptr_parameter("IVRSystem_012_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_012_GetDXGIOutputInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_012_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_012_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_012_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_012_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_012_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_012_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_012_SetDisplayVisibility", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_012_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_012_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_012_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_012_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_012_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_012_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_012_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_012_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_012_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_012_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_012_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_012_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_012_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_ApplyTransform, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_012_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_ApplyTransform((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_012_ApplyTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_012_ApplyTransform", (void *)1);
    check_ptr_parameter("IVRSystem_012_ApplyTransform", (void *)2);
    check_ptr_parameter("IVRSystem_012_ApplyTransform", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_012_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetTrackedDeviceIndexForControllerRole(1);
    check_ptr_parameter("IVRSystem_012_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetTrackedDeviceIndexForControllerRole", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
    ETrackedControllerRole (__stdcall *capi_IVRSystem_012_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetControllerRoleForTrackedDeviceIndex(1);
    check_ptr_parameter("IVRSystem_012_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetControllerRoleForTrackedDeviceIndex", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetTrackedDeviceClass, 1, FALSE, FALSE);
    ETrackedDeviceClass (__stdcall *capi_IVRSystem_012_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_012_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_012_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_012_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_012_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_012_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_012_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_012_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_012_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_012_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_012_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_012_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_012_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_012_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_012_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_012_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_012_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_012_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_012_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_012_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_012_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_012_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_012_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_012_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_012_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_012_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_012_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_012_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_012_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_012_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_012_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_012_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_012_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_PollNextEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_012_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_PollNextEvent((void *)1, 2);
    check_ptr_parameter("IVRSystem_012_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_012_PollNextEvent", (void *)1);
    check_uint32_parameter("IVRSystem_012_PollNextEvent", 2);

    init_thunk(t, this_ptr_value, IVRSystem_012_PollNextEventWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_012_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSystem_012_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_012_PollNextEventWithPose", (void *)2);
    check_uint32_parameter("IVRSystem_012_PollNextEventWithPose", 3);
    check_ptr_parameter("IVRSystem_012_PollNextEventWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_012_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_012_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetHiddenAreaMesh, 2, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_012_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetHiddenAreaMesh(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_012_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_012_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetHiddenAreaMesh", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetControllerState, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_012_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetControllerState(1, (void *)2);
    check_ptr_parameter("IVRSystem_012_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_012_GetControllerState", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetControllerStateWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_012_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSystem_012_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_012_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_012_GetControllerStateWithPose", (void *)3);
    check_ptr_parameter("IVRSystem_012_GetControllerStateWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_012_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_012_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_012_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_012_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_012_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_012_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_012_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_012_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_012_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_CaptureInputFocus, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_012_CaptureInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_CaptureInputFocus();
    check_ptr_parameter("IVRSystem_012_CaptureInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_012_ReleaseInputFocus, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_012_ReleaseInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_ReleaseInputFocus();
    check_ptr_parameter("IVRSystem_012_ReleaseInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_012_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_012_IsInputFocusCapturedByAnotherProcess)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_IsInputFocusCapturedByAnotherProcess();
    check_ptr_parameter("IVRSystem_012_IsInputFocusCapturedByAnotherProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_012_DriverDebugRequest, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_012_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_DriverDebugRequest(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRSystem_012_DriverDebugRequest", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_DriverDebugRequest", 1);
    check_ptr_parameter("IVRSystem_012_DriverDebugRequest", (void *)2);
    check_ptr_parameter("IVRSystem_012_DriverDebugRequest", (void *)3);
    check_uint32_parameter("IVRSystem_012_DriverDebugRequest", 4);

    init_thunk(t, this_ptr_value, IVRSystem_012_PerformFirmwareUpdate, 1, FALSE, FALSE);
    EVRFirmwareError (__stdcall *capi_IVRSystem_012_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_012_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_012_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_012_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_012_AcknowledgeQuit_Exiting)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_AcknowledgeQuit_Exiting();
    check_ptr_parameter("IVRSystem_012_AcknowledgeQuit_Exiting", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_012_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_012_AcknowledgeQuit_UserPrompt)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_012_AcknowledgeQuit_UserPrompt();
    check_ptr_parameter("IVRSystem_012_AcknowledgeQuit_UserPrompt", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_016(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_016_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_016_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_016_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_016_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_016_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_016_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_016_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_016_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_016_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_016_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_016_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_016_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_016_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_016_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_016_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_016_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_016_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_016_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_016_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_016_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_016_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_016_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_016_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_016_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_016_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_016_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_016_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_016_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_016_Submit", 1);
    check_ptr_parameter("IVRCompositor_016_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_016_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_016_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_016_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_016_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_016_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_016_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_016_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_016_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_016_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_016_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_016_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_016_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_GetCumulativeStats, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_GetCumulativeStats((void *)1, 2);
    check_ptr_parameter("IVRCompositor_016_GetCumulativeStats", this_ptr_value);
    check_ptr_parameter("IVRCompositor_016_GetCumulativeStats", (void *)1);
    check_uint32_parameter("IVRCompositor_016_GetCumulativeStats", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_016_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_016_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_016_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_016_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_016_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_016_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_016_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_016_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_016_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_016_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_016_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_016_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_016_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_016_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_016_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_016_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_016_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_016_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_016_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_016_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_016_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_016_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_CompositorQuit();
    check_ptr_parameter("IVRCompositor_016_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_016_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_IsFullscreen();
    check_ptr_parameter("IVRCompositor_016_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_016_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_016_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_016_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_016_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_016_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_CanRenderScene();
    check_ptr_parameter("IVRCompositor_016_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_016_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_016_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_016_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_016_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_016_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_016_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_016_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_016_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_016_ForceInterleavedReprojectionOn", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_016_ForceReconnectProcess, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_ForceReconnectProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_ForceReconnectProcess();
    check_ptr_parameter("IVRCompositor_016_ForceReconnectProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_016_SuspendRendering, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_SuspendRendering)(bool bSuspend) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_SuspendRendering(1);
    check_ptr_parameter("IVRCompositor_016_SuspendRendering", this_ptr_value);
    check_bool_parameter("IVRCompositor_016_SuspendRendering", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_016_GetMirrorTextureD3D11, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_016_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_016_GetMirrorTextureD3D11", this_ptr_value);
    check_uint32_parameter("IVRCompositor_016_GetMirrorTextureD3D11", 1);
    check_ptr_parameter("IVRCompositor_016_GetMirrorTextureD3D11", (void *)2);
    check_ptr_parameter("IVRCompositor_016_GetMirrorTextureD3D11", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_016_GetMirrorTextureGL, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_016_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_GetMirrorTextureGL(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_016_GetMirrorTextureGL", this_ptr_value);
    check_uint32_parameter("IVRCompositor_016_GetMirrorTextureGL", 1);
    check_ptr_parameter("IVRCompositor_016_GetMirrorTextureGL", (void *)2);
    check_ptr_parameter("IVRCompositor_016_GetMirrorTextureGL", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_016_ReleaseSharedGLTexture, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_016_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_ReleaseSharedGLTexture(1, (void *)2);
    check_ptr_parameter("IVRCompositor_016_ReleaseSharedGLTexture", this_ptr_value);
    check_uint32_parameter("IVRCompositor_016_ReleaseSharedGLTexture", 1);
    check_ptr_parameter("IVRCompositor_016_ReleaseSharedGLTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_016_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_LockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_016_LockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_016_LockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_016_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_016_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_016_UnlockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_016_UnlockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_016_UnlockGLSharedTextureForAccess", (void *)1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSettings_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSettings_001_GetSettingsErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSettings_001_GetSettingsErrorNameFromEnum)(EVRSettingsError eError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_001_GetSettingsErrorNameFromEnum(1);
    check_ptr_parameter("IVRSettings_001_GetSettingsErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSettings_001_GetSettingsErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSettings_001_Sync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSettings_001_Sync)(bool bForce, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_001_Sync(1, (void *)2);
    check_ptr_parameter("IVRSettings_001_Sync", this_ptr_value);
    check_bool_parameter("IVRSettings_001_Sync", 1);
    check_ptr_parameter("IVRSettings_001_Sync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSettings_001_GetBool, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSettings_001_GetBool)(const char * pchSection, const char * pchSettingsKey, bool bDefaultValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_001_GetBool((void *)1, (void *)2, 1, (void *)4);
    check_ptr_parameter("IVRSettings_001_GetBool", this_ptr_value);
    check_ptr_parameter("IVRSettings_001_GetBool", (void *)1);
    check_ptr_parameter("IVRSettings_001_GetBool", (void *)2);
    check_bool_parameter("IVRSettings_001_GetBool", 1);
    check_ptr_parameter("IVRSettings_001_GetBool", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_001_SetBool, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_001_SetBool)(const char * pchSection, const char * pchSettingsKey, bool bValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_001_SetBool((void *)1, (void *)2, 1, (void *)4);
    check_ptr_parameter("IVRSettings_001_SetBool", this_ptr_value);
    check_ptr_parameter("IVRSettings_001_SetBool", (void *)1);
    check_ptr_parameter("IVRSettings_001_SetBool", (void *)2);
    check_bool_parameter("IVRSettings_001_SetBool", 1);
    check_ptr_parameter("IVRSettings_001_SetBool", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_001_GetInt32, 4, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSettings_001_GetInt32)(const char * pchSection, const char * pchSettingsKey, int32_t nDefaultValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_001_GetInt32((void *)1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSettings_001_GetInt32", this_ptr_value);
    check_ptr_parameter("IVRSettings_001_GetInt32", (void *)1);
    check_ptr_parameter("IVRSettings_001_GetInt32", (void *)2);
    check_uint32_parameter("IVRSettings_001_GetInt32", 3);
    check_ptr_parameter("IVRSettings_001_GetInt32", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_001_SetInt32, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_001_SetInt32)(const char * pchSection, const char * pchSettingsKey, int32_t nValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_001_SetInt32((void *)1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSettings_001_SetInt32", this_ptr_value);
    check_ptr_parameter("IVRSettings_001_SetInt32", (void *)1);
    check_ptr_parameter("IVRSettings_001_SetInt32", (void *)2);
    check_uint32_parameter("IVRSettings_001_SetInt32", 3);
    check_ptr_parameter("IVRSettings_001_SetInt32", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_001_GetFloat, 4, TRUE, FALSE);
    float (__stdcall *capi_IVRSettings_001_GetFloat)(const char * pchSection, const char * pchSettingsKey, float flDefaultValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_001_GetFloat((void *)1, (void *)2, 3.0f, (void *)4);
    check_ptr_parameter("IVRSettings_001_GetFloat", this_ptr_value);
    check_ptr_parameter("IVRSettings_001_GetFloat", (void *)1);
    check_ptr_parameter("IVRSettings_001_GetFloat", (void *)2);
    check_float_parameter("IVRSettings_001_GetFloat", 3.0f);
    check_ptr_parameter("IVRSettings_001_GetFloat", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_001_SetFloat, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSettings_001_SetFloat)(const char * pchSection, const char * pchSettingsKey, float flValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_001_SetFloat((void *)1, (void *)2, 3.0f, (void *)4);
    check_ptr_parameter("IVRSettings_001_SetFloat", this_ptr_value);
    check_ptr_parameter("IVRSettings_001_SetFloat", (void *)1);
    check_ptr_parameter("IVRSettings_001_SetFloat", (void *)2);
    check_float_parameter("IVRSettings_001_SetFloat", 3.0f);
    check_ptr_parameter("IVRSettings_001_SetFloat", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_001_GetString, 6, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_001_GetString)(const char * pchSection, const char * pchSettingsKey, char * pchValue, uint32_t unValueLen, const char * pchDefaultValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_001_GetString((void *)1, (void *)2, (void *)3, 4, (void *)5, (void *)6);
    check_ptr_parameter("IVRSettings_001_GetString", this_ptr_value);
    check_ptr_parameter("IVRSettings_001_GetString", (void *)1);
    check_ptr_parameter("IVRSettings_001_GetString", (void *)2);
    check_ptr_parameter("IVRSettings_001_GetString", (void *)3);
    check_uint32_parameter("IVRSettings_001_GetString", 4);
    check_ptr_parameter("IVRSettings_001_GetString", (void *)5);
    check_ptr_parameter("IVRSettings_001_GetString", (void *)6);

    init_thunk(t, this_ptr_value, IVRSettings_001_SetString, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_001_SetString)(const char * pchSection, const char * pchSettingsKey, const char * pchValue, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_001_SetString((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSettings_001_SetString", this_ptr_value);
    check_ptr_parameter("IVRSettings_001_SetString", (void *)1);
    check_ptr_parameter("IVRSettings_001_SetString", (void *)2);
    check_ptr_parameter("IVRSettings_001_SetString", (void *)3);
    check_ptr_parameter("IVRSettings_001_SetString", (void *)4);

    init_thunk(t, this_ptr_value, IVRSettings_001_RemoveSection, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_001_RemoveSection)(const char * pchSection, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_001_RemoveSection((void *)1, (void *)2);
    check_ptr_parameter("IVRSettings_001_RemoveSection", this_ptr_value);
    check_ptr_parameter("IVRSettings_001_RemoveSection", (void *)1);
    check_ptr_parameter("IVRSettings_001_RemoveSection", (void *)2);

    init_thunk(t, this_ptr_value, IVRSettings_001_RemoveKeyInSection, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSettings_001_RemoveKeyInSection)(const char * pchSection, const char * pchSettingsKey, EVRSettingsError * peError) = (void *)t;

    clear_parameters();
    capi_IVRSettings_001_RemoveKeyInSection((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSettings_001_RemoveKeyInSection", this_ptr_value);
    check_ptr_parameter("IVRSettings_001_RemoveKeyInSection", (void *)1);
    check_ptr_parameter("IVRSettings_001_RemoveKeyInSection", (void *)2);
    check_ptr_parameter("IVRSettings_001_RemoveKeyInSection", (void *)3);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRApplications_005(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRApplications_005_AddApplicationManifest, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_005_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_AddApplicationManifest((void *)1, 1);
    check_ptr_parameter("IVRApplications_005_AddApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_AddApplicationManifest", (void *)1);
    check_bool_parameter("IVRApplications_005_AddApplicationManifest", 1);

    init_thunk(t, this_ptr_value, IVRApplications_005_RemoveApplicationManifest, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_005_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_RemoveApplicationManifest((void *)1);
    check_ptr_parameter("IVRApplications_005_RemoveApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_RemoveApplicationManifest", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_005_IsApplicationInstalled, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_005_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_IsApplicationInstalled((void *)1);
    check_ptr_parameter("IVRApplications_005_IsApplicationInstalled", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_IsApplicationInstalled", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_005_GetApplicationCount)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_GetApplicationCount();
    check_ptr_parameter("IVRApplications_005_GetApplicationCount", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationKeyByIndex, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_005_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_GetApplicationKeyByIndex(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_005_GetApplicationKeyByIndex", this_ptr_value);
    check_uint32_parameter("IVRApplications_005_GetApplicationKeyByIndex", 1);
    check_ptr_parameter("IVRApplications_005_GetApplicationKeyByIndex", (void *)2);
    check_uint32_parameter("IVRApplications_005_GetApplicationKeyByIndex", 3);

    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_005_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_GetApplicationKeyByProcessId(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_005_GetApplicationKeyByProcessId", this_ptr_value);
    check_uint32_parameter("IVRApplications_005_GetApplicationKeyByProcessId", 1);
    check_ptr_parameter("IVRApplications_005_GetApplicationKeyByProcessId", (void *)2);
    check_uint32_parameter("IVRApplications_005_GetApplicationKeyByProcessId", 3);

    init_thunk(t, this_ptr_value, IVRApplications_005_LaunchApplication, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_005_LaunchApplication)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_LaunchApplication((void *)1);
    check_ptr_parameter("IVRApplications_005_LaunchApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_LaunchApplication", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_005_LaunchTemplateApplication, 4, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_005_LaunchTemplateApplication)(const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_LaunchTemplateApplication((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRApplications_005_LaunchTemplateApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_LaunchTemplateApplication", (void *)1);
    check_ptr_parameter("IVRApplications_005_LaunchTemplateApplication", (void *)2);
    check_ptr_parameter("IVRApplications_005_LaunchTemplateApplication", (void *)3);
    check_uint32_parameter("IVRApplications_005_LaunchTemplateApplication", 4);

    init_thunk(t, this_ptr_value, IVRApplications_005_LaunchDashboardOverlay, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_005_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_LaunchDashboardOverlay((void *)1);
    check_ptr_parameter("IVRApplications_005_LaunchDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_LaunchDashboardOverlay", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_005_CancelApplicationLaunch, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_005_CancelApplicationLaunch)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_CancelApplicationLaunch((void *)1);
    check_ptr_parameter("IVRApplications_005_CancelApplicationLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_CancelApplicationLaunch", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_005_IdentifyApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_005_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_IdentifyApplication(1, (void *)2);
    check_ptr_parameter("IVRApplications_005_IdentifyApplication", this_ptr_value);
    check_uint32_parameter("IVRApplications_005_IdentifyApplication", 1);
    check_ptr_parameter("IVRApplications_005_IdentifyApplication", (void *)2);

    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationProcessId, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_005_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_GetApplicationProcessId((void *)1);
    check_ptr_parameter("IVRApplications_005_GetApplicationProcessId", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_GetApplicationProcessId", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_005_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_GetApplicationsErrorNameFromEnum(1);
    check_ptr_parameter("IVRApplications_005_GetApplicationsErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_005_GetApplicationsErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationPropertyString, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_005_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyString", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyString", (void *)1);
    check_uint32_parameter("IVRApplications_005_GetApplicationPropertyString", 2);
    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyString", (void *)3);
    check_uint32_parameter("IVRApplications_005_GetApplicationPropertyString", 4);
    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyString", (void *)5);

    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationPropertyBool, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_005_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_GetApplicationPropertyBool((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyBool", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyBool", (void *)1);
    check_uint32_parameter("IVRApplications_005_GetApplicationPropertyBool", 2);
    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyBool", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationPropertyUint64, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRApplications_005_GetApplicationPropertyUint64)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_GetApplicationPropertyUint64((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyUint64", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyUint64", (void *)1);
    check_uint32_parameter("IVRApplications_005_GetApplicationPropertyUint64", 2);
    check_ptr_parameter("IVRApplications_005_GetApplicationPropertyUint64", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_005_SetApplicationAutoLaunch, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_005_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_SetApplicationAutoLaunch((void *)1, 1);
    check_ptr_parameter("IVRApplications_005_SetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_SetApplicationAutoLaunch", (void *)1);
    check_bool_parameter("IVRApplications_005_SetApplicationAutoLaunch", 1);

    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationAutoLaunch, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_005_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_GetApplicationAutoLaunch((void *)1);
    check_ptr_parameter("IVRApplications_005_GetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_GetApplicationAutoLaunch", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_005_GetStartingApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_005_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_GetStartingApplication((void *)1, 2);
    check_ptr_parameter("IVRApplications_005_GetStartingApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_GetStartingApplication", (void *)1);
    check_uint32_parameter("IVRApplications_005_GetStartingApplication", 2);

    init_thunk(t, this_ptr_value, IVRApplications_005_GetTransitionState, 0, FALSE, FALSE);
    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_005_GetTransitionState)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_GetTransitionState();
    check_ptr_parameter("IVRApplications_005_GetTransitionState", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_005_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_005_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_PerformApplicationPrelaunchCheck((void *)1);
    check_ptr_parameter("IVRApplications_005_PerformApplicationPrelaunchCheck", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_PerformApplicationPrelaunchCheck", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_005_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_005_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_GetApplicationsTransitionStateNameFromEnum(1);
    check_ptr_parameter("IVRApplications_005_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_005_GetApplicationsTransitionStateNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_005_IsQuitUserPromptRequested, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_005_IsQuitUserPromptRequested)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_IsQuitUserPromptRequested();
    check_ptr_parameter("IVRApplications_005_IsQuitUserPromptRequested", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_005_LaunchInternalProcess, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_005_LaunchInternalProcess)(const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory) = (void *)t;

    clear_parameters();
    capi_IVRApplications_005_LaunchInternalProcess((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRApplications_005_LaunchInternalProcess", this_ptr_value);
    check_ptr_parameter("IVRApplications_005_LaunchInternalProcess", (void *)1);
    check_ptr_parameter("IVRApplications_005_LaunchInternalProcess", (void *)2);
    check_ptr_parameter("IVRApplications_005_LaunchInternalProcess", (void *)3);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_015(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_015_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_015_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_015_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_015_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_015_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_015_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_015_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_015_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_015_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_015_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_015_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_015_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_015_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_015_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_015_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_015_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_015_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_015_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_015_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_015_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_015_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_015_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_015_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_015_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_015_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_015_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_015_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_015_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_015_Submit", 1);
    check_ptr_parameter("IVRCompositor_015_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_015_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_015_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_015_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_015_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_015_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_015_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_015_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_015_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_015_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_015_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_015_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_015_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_GetCumulativeStats, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_GetCumulativeStats((void *)1, 2);
    check_ptr_parameter("IVRCompositor_015_GetCumulativeStats", this_ptr_value);
    check_ptr_parameter("IVRCompositor_015_GetCumulativeStats", (void *)1);
    check_uint32_parameter("IVRCompositor_015_GetCumulativeStats", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_015_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_015_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_015_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_015_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_015_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_015_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_015_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_015_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_015_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_015_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_015_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_015_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_015_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_015_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_015_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_015_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_015_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_015_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_015_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_015_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_015_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_015_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_CompositorQuit();
    check_ptr_parameter("IVRCompositor_015_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_015_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_IsFullscreen();
    check_ptr_parameter("IVRCompositor_015_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_015_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_015_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_015_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_015_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_015_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_CanRenderScene();
    check_ptr_parameter("IVRCompositor_015_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_015_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_015_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_015_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_015_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_015_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_015_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_015_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_015_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_015_ForceInterleavedReprojectionOn", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_015_ForceReconnectProcess, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_ForceReconnectProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_ForceReconnectProcess();
    check_ptr_parameter("IVRCompositor_015_ForceReconnectProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_SuspendRendering, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_SuspendRendering)(bool bSuspend) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_SuspendRendering(1);
    check_ptr_parameter("IVRCompositor_015_SuspendRendering", this_ptr_value);
    check_bool_parameter("IVRCompositor_015_SuspendRendering", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_015_RequestScreenshot, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_015_RequestScreenshot)(EVRScreenshotType type, const char * pchDestinationFileName, const char * pchVRDestinationFileName) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_RequestScreenshot(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_015_RequestScreenshot", this_ptr_value);
    check_uint32_parameter("IVRCompositor_015_RequestScreenshot", 1);
    check_ptr_parameter("IVRCompositor_015_RequestScreenshot", (void *)2);
    check_ptr_parameter("IVRCompositor_015_RequestScreenshot", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_015_GetCurrentScreenshotType, 0, FALSE, FALSE);
    EVRScreenshotType (__stdcall *capi_IVRCompositor_015_GetCurrentScreenshotType)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_GetCurrentScreenshotType();
    check_ptr_parameter("IVRCompositor_015_GetCurrentScreenshotType", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_015_GetMirrorTextureD3D11, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_015_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_015_GetMirrorTextureD3D11", this_ptr_value);
    check_uint32_parameter("IVRCompositor_015_GetMirrorTextureD3D11", 1);
    check_ptr_parameter("IVRCompositor_015_GetMirrorTextureD3D11", (void *)2);
    check_ptr_parameter("IVRCompositor_015_GetMirrorTextureD3D11", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_015_GetMirrorTextureGL, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_015_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_GetMirrorTextureGL(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_015_GetMirrorTextureGL", this_ptr_value);
    check_uint32_parameter("IVRCompositor_015_GetMirrorTextureGL", 1);
    check_ptr_parameter("IVRCompositor_015_GetMirrorTextureGL", (void *)2);
    check_ptr_parameter("IVRCompositor_015_GetMirrorTextureGL", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_015_ReleaseSharedGLTexture, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_015_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_ReleaseSharedGLTexture(1, (void *)2);
    check_ptr_parameter("IVRCompositor_015_ReleaseSharedGLTexture", this_ptr_value);
    check_uint32_parameter("IVRCompositor_015_ReleaseSharedGLTexture", 1);
    check_ptr_parameter("IVRCompositor_015_ReleaseSharedGLTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_015_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_LockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_015_LockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_015_LockGLSharedTextureForAccess", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_015_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_015_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_015_UnlockGLSharedTextureForAccess((void *)1);
    check_ptr_parameter("IVRCompositor_015_UnlockGLSharedTextureForAccess", this_ptr_value);
    check_ptr_parameter("IVRCompositor_015_UnlockGLSharedTextureForAccess", (void *)1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_012(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_012_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_012_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_012_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_012_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_012_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_012_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_012_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_012_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_012_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_012_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetHighQualityOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_012_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_012_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_012_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_012_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_012_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_012_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_012_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_012_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_012_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_012_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_012_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_012_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_012_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_012_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_012_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_012_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_012_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_012_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_012_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_012_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_012_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_012_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_012_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_012_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_012_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_012_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_012_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_012_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_012_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_012_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_012_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_012_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_012_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_012_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_012_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_012_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_012_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_012_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_012_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_012_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_012_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_012_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_012_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_012_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_012_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_012_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_012_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_012_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_012_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_012_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_012_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_HideOverlay(1);
    check_ptr_parameter("IVROverlay_012_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_012_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_012_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_012_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_012_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_012_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_012_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_012_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_012_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_012_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_012_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_012_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_012_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_012_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_012_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_012_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_012_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_012_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_012_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_012_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_012_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_012_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_012_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_012_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_012_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_012_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_012_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetGamepadFocusOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_012_GetGamepadFocusOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetGamepadFocusOverlay();
    check_ptr_parameter("IVROverlay_012_GetGamepadFocusOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetGamepadFocusOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetGamepadFocusOverlay(1);
    check_ptr_parameter("IVROverlay_012_SetGamepadFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetGamepadFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayNeighbor, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayNeighbor(1, 2, 3);
    check_ptr_parameter("IVROverlay_012_SetOverlayNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_012_SetOverlayNeighbor", 1);
    check_uint64_parameter("IVROverlay_012_SetOverlayNeighbor", 2);
    check_uint64_parameter("IVROverlay_012_SetOverlayNeighbor", 3);

    init_thunk(t, this_ptr_value, IVROverlay_012_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_MoveGamepadFocusToNeighbor(1, 2);
    check_ptr_parameter("IVROverlay_012_MoveGamepadFocusToNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_012_MoveGamepadFocusToNeighbor", 1);
    check_uint64_parameter("IVROverlay_012_MoveGamepadFocusToNeighbor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_012_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_012_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_012_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_012_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_012_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_012_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_012_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_012_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTexture, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8);
    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_012_GetOverlayTexture", (void *)8);

    init_thunk(t, this_ptr_value, IVROverlay_012_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_012_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetOverlayTextureSize, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetOverlayTextureSize(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_012_GetOverlayTextureSize", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetOverlayTextureSize", 1);
    check_ptr_parameter("IVROverlay_012_GetOverlayTextureSize", (void *)2);
    check_ptr_parameter("IVROverlay_012_GetOverlayTextureSize", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_012_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_012_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_012_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_012_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_012_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_012_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_012_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_012_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_012_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_012_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_012_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_012_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_012_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_012_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_012_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_012_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_012_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_012_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_012_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_012_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_012_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_012_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_012_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_012_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_012_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_012_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_012_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_012_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_012_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_012_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_012_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_012_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_012_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_012_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_012_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_012_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_012_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_012_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_012_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_012_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_012_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_012_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_012_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_012_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_012_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_012_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_HideKeyboard();
    check_ptr_parameter("IVROverlay_012_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_012_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_012_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_012_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_012_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_012_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_012_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_012_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_012_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_012_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_012_SetKeyboardPositionForOverlay", DEFAULT_RECT);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRTrackedCamera_002(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_GetCameraErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRTrackedCamera_002_GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_002_GetCameraErrorNameFromEnum(1);
    check_ptr_parameter("IVRTrackedCamera_002_GetCameraErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_002_GetCameraErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_HasCamera, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_002_HasCamera(1, (void *)2);
    check_ptr_parameter("IVRTrackedCamera_002_HasCamera", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_002_HasCamera", 1);
    check_ptr_parameter("IVRTrackedCamera_002_HasCamera", (void *)2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_GetCameraFrameSize, 5, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_002_GetCameraFrameSize(1, 2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_002_GetCameraFrameSize", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_002_GetCameraFrameSize", 1);
    check_uint32_parameter("IVRTrackedCamera_002_GetCameraFrameSize", 2);
    check_ptr_parameter("IVRTrackedCamera_002_GetCameraFrameSize", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_002_GetCameraFrameSize", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_002_GetCameraFrameSize", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_GetCameraIntrinisics, 4, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_GetCameraIntrinisics)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_002_GetCameraIntrinisics(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRTrackedCamera_002_GetCameraIntrinisics", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_002_GetCameraIntrinisics", 1);
    check_uint32_parameter("IVRTrackedCamera_002_GetCameraIntrinisics", 2);
    check_ptr_parameter("IVRTrackedCamera_002_GetCameraIntrinisics", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_002_GetCameraIntrinisics", (void *)4);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_GetCameraProjection, 5, TRUE, TRUE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_002_GetCameraProjection(1, 2, 3.0f, 4.0f, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_002_GetCameraProjection", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_002_GetCameraProjection", 1);
    check_uint32_parameter("IVRTrackedCamera_002_GetCameraProjection", 2);
    check_float_parameter("IVRTrackedCamera_002_GetCameraProjection", 3.0f);
    check_float_parameter("IVRTrackedCamera_002_GetCameraProjection", 4.0f);
    check_ptr_parameter("IVRTrackedCamera_002_GetCameraProjection", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_AcquireVideoStreamingService, 2, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_002_AcquireVideoStreamingService(1, (void *)2);
    check_ptr_parameter("IVRTrackedCamera_002_AcquireVideoStreamingService", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_002_AcquireVideoStreamingService", 1);
    check_ptr_parameter("IVRTrackedCamera_002_AcquireVideoStreamingService", (void *)2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_ReleaseVideoStreamingService, 1, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_002_ReleaseVideoStreamingService(1);
    check_ptr_parameter("IVRTrackedCamera_002_ReleaseVideoStreamingService", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_002_ReleaseVideoStreamingService", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_002_GetVideoStreamFrameBuffer, 6, FALSE, FALSE);
    EVRTrackedCameraError (__stdcall *capi_IVRTrackedCamera_002_GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_002_GetVideoStreamFrameBuffer(1, 2, (void *)3, 4, (void *)5, 6);
    check_ptr_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", 1);
    check_uint32_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", 2);
    check_ptr_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", (void *)3);
    check_uint32_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", 4);
    check_ptr_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", (void *)5);
    check_uint32_parameter("IVRTrackedCamera_002_GetVideoStreamFrameBuffer", 6);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_014(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_014_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_014_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_014_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_014_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_014_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_014_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_014_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_014_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_014_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_014_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_014_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_014_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_014_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_014_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_014_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_014_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_014_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_014_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_014_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_014_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_014_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_014_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_014_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_014_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_014_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_014_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_014_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_014_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_014_Submit", 1);
    check_ptr_parameter("IVRCompositor_014_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_014_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_014_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_014_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_014_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_014_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_014_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_014_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_014_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_014_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_014_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_014_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_014_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_014_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_014_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_014_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_014_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_014_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_014_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_014_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_014_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_014_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_014_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_014_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_014_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_014_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_014_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_014_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_014_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_014_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_014_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_014_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_014_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_014_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_CompositorQuit();
    check_ptr_parameter("IVRCompositor_014_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_014_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_IsFullscreen();
    check_ptr_parameter("IVRCompositor_014_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_014_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_014_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_014_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_014_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_014_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_CanRenderScene();
    check_ptr_parameter("IVRCompositor_014_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_014_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_014_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_014_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_014_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_014_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_014_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_014_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_014_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_014_ForceInterleavedReprojectionOn", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_014_ForceReconnectProcess, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_ForceReconnectProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_ForceReconnectProcess();
    check_ptr_parameter("IVRCompositor_014_ForceReconnectProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_014_SuspendRendering, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_014_SuspendRendering)(bool bSuspend) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_014_SuspendRendering(1);
    check_ptr_parameter("IVRCompositor_014_SuspendRendering", this_ptr_value);
    check_bool_parameter("IVRCompositor_014_SuspendRendering", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_011(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_011_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_011_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_011_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_011_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_011_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_011_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_011_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_011_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_011_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_011_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetHighQualityOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_011_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_011_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_011_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_011_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_011_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_011_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_011_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_011_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_011_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_011_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_011_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_011_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_011_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_011_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_011_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_011_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_011_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_011_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayRenderingPid, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayRenderingPid(1, 2);
    check_ptr_parameter("IVROverlay_011_SetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayRenderingPid", 1);
    check_uint32_parameter("IVROverlay_011_SetOverlayRenderingPid", 2);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayRenderingPid, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_011_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayRenderingPid(1);
    check_ptr_parameter("IVROverlay_011_GetOverlayRenderingPid", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayRenderingPid", 1);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_011_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_011_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_011_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_011_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_011_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_011_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_011_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_011_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_011_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_011_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_011_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_011_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_011_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_011_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_011_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_011_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_011_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_011_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_011_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_011_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_011_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_011_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_011_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_011_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_011_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_011_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_011_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_011_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_011_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_HideOverlay(1);
    check_ptr_parameter("IVROverlay_011_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_011_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_011_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_011_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_011_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_011_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_011_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_011_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_011_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_011_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_011_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_011_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_011_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_011_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_011_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_011_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_011_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_011_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_011_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_011_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_011_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_011_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_011_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_011_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_011_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_011_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_011_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetGamepadFocusOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_011_GetGamepadFocusOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetGamepadFocusOverlay();
    check_ptr_parameter("IVROverlay_011_GetGamepadFocusOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetGamepadFocusOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetGamepadFocusOverlay(1);
    check_ptr_parameter("IVROverlay_011_SetGamepadFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetGamepadFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayNeighbor, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayNeighbor(1, 2, 3);
    check_ptr_parameter("IVROverlay_011_SetOverlayNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_011_SetOverlayNeighbor", 1);
    check_uint64_parameter("IVROverlay_011_SetOverlayNeighbor", 2);
    check_uint64_parameter("IVROverlay_011_SetOverlayNeighbor", 3);

    init_thunk(t, this_ptr_value, IVROverlay_011_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_MoveGamepadFocusToNeighbor(1, 2);
    check_ptr_parameter("IVROverlay_011_MoveGamepadFocusToNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_011_MoveGamepadFocusToNeighbor", 1);
    check_uint64_parameter("IVROverlay_011_MoveGamepadFocusToNeighbor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_011_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_011_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_011_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_011_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_011_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_011_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_011_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_011_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetOverlayTexture, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8);
    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)2);
    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)3);
    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)4);
    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)5);
    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)6);
    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)7);
    check_ptr_parameter("IVROverlay_011_GetOverlayTexture", (void *)8);

    init_thunk(t, this_ptr_value, IVROverlay_011_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_ReleaseNativeOverlayHandle(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_ReleaseNativeOverlayHandle", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_ReleaseNativeOverlayHandle", 1);
    check_ptr_parameter("IVROverlay_011_ReleaseNativeOverlayHandle", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_011_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_011_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_011_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_011_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_011_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_011_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_011_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_011_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_011_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_011_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_011_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_011_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_011_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_011_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_011_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_011_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_011_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_011_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_011_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_011_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_011_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_011_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_011_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_011_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_011_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_011_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_011_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_011_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_011_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_011_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_011_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_011_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_011_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_011_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_011_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_011_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_011_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_011_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_011_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_011_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_011_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_011_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_011_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_011_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_011_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_HideKeyboard();
    check_ptr_parameter("IVROverlay_011_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_011_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_011_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_011_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_011_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_011_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_011_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_011_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_011_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_011_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_011_SetKeyboardPositionForOverlay", DEFAULT_RECT);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_013(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_013_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_013_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_013_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_013_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_013_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_013_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_013_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_013_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_013_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_013_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_013_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_013_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_013_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_013_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_013_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_013_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_013_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_013_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_013_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_013_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_013_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_013_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_013_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_013_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_013_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_013_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_013_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_013_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_013_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_013_Submit", 1);
    check_ptr_parameter("IVRCompositor_013_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_013_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_013_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_013_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_013_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_013_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_013_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_013_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_013_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_013_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_013_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_013_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_013_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_013_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_013_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_013_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_013_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_013_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_013_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_013_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_013_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_013_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_013_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_013_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_013_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_013_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_013_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_013_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_013_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_013_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_013_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_013_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_013_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_013_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_013_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_013_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_013_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_013_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_013_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_013_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_013_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_CompositorQuit();
    check_ptr_parameter("IVRCompositor_013_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_013_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_IsFullscreen();
    check_ptr_parameter("IVRCompositor_013_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_013_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_013_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_013_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_013_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_013_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_CanRenderScene();
    check_ptr_parameter("IVRCompositor_013_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_013_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_013_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_013_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_013_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_013_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_013_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_013_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_013_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_013_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_013_ShouldAppRenderWithLowResources", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_013_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_013_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_013_ForceInterleavedReprojectionOn(1);
    check_ptr_parameter("IVRCompositor_013_ForceInterleavedReprojectionOn", this_ptr_value);
    check_bool_parameter("IVRCompositor_013_ForceInterleavedReprojectionOn", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_011(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_011_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_011_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_011_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_011_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetProjectionMatrix, 5, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_011_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
    check_ptr_parameter("IVRSystem_011_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_011_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_011_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_011_GetProjectionMatrix", 3.0f);
    check_uint32_parameter("IVRSystem_011_GetProjectionMatrix", 4);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_011_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_011_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_011_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_011_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_011_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_011_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_011_ComputeDistortion, 4, TRUE, TRUE);
    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_011_ComputeDistortion)(DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_011_ComputeDistortion", this_ptr_value);
    check_ptr_parameter("IVRSystem_011_ComputeDistortion", data_ptr_value);
    check_uint32_parameter("IVRSystem_011_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_011_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_011_ComputeDistortion", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_011_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_011_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_011_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_011_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_011_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_011_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_011_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_011_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_011_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetDXGIOutputInfo, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_011_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetDXGIOutputInfo((void *)1);
    check_ptr_parameter("IVRSystem_011_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_011_GetDXGIOutputInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_011_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_011_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_011_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_011_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_011_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_011_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_011_SetDisplayVisibility", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_011_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_011_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_011_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_011_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_011_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_011_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_011_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_011_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_011_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_011_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_011_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_011_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_011_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_ApplyTransform, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_011_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_ApplyTransform((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_011_ApplyTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_011_ApplyTransform", (void *)1);
    check_ptr_parameter("IVRSystem_011_ApplyTransform", (void *)2);
    check_ptr_parameter("IVRSystem_011_ApplyTransform", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_011_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetTrackedDeviceIndexForControllerRole(1);
    check_ptr_parameter("IVRSystem_011_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetTrackedDeviceIndexForControllerRole", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
    ETrackedControllerRole (__stdcall *capi_IVRSystem_011_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetControllerRoleForTrackedDeviceIndex(1);
    check_ptr_parameter("IVRSystem_011_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetControllerRoleForTrackedDeviceIndex", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetTrackedDeviceClass, 1, FALSE, FALSE);
    ETrackedDeviceClass (__stdcall *capi_IVRSystem_011_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_011_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_011_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_011_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_011_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_011_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_011_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_011_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_011_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_011_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_011_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_011_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_011_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_011_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_011_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_011_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_011_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_011_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_011_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_011_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_011_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_011_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_011_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_011_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_011_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_011_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_011_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_011_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_011_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_011_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_011_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_011_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_011_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_PollNextEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_011_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_PollNextEvent((void *)1, 2);
    check_ptr_parameter("IVRSystem_011_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_011_PollNextEvent", (void *)1);
    check_uint32_parameter("IVRSystem_011_PollNextEvent", 2);

    init_thunk(t, this_ptr_value, IVRSystem_011_PollNextEventWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_011_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVRSystem_011_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_011_PollNextEventWithPose", (void *)2);
    check_uint32_parameter("IVRSystem_011_PollNextEventWithPose", 3);
    check_ptr_parameter("IVRSystem_011_PollNextEventWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_011_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_011_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetHiddenAreaMesh, 2, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_011_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetHiddenAreaMesh(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_011_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_011_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetHiddenAreaMesh", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetControllerState, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_011_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetControllerState(1, (void *)2);
    check_ptr_parameter("IVRSystem_011_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_011_GetControllerState", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetControllerStateWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_011_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSystem_011_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_011_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_011_GetControllerStateWithPose", (void *)3);
    check_ptr_parameter("IVRSystem_011_GetControllerStateWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_011_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_011_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_011_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_011_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_011_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_011_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_011_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_011_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_011_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_CaptureInputFocus, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_011_CaptureInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_CaptureInputFocus();
    check_ptr_parameter("IVRSystem_011_CaptureInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_011_ReleaseInputFocus, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_011_ReleaseInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_ReleaseInputFocus();
    check_ptr_parameter("IVRSystem_011_ReleaseInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_011_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_011_IsInputFocusCapturedByAnotherProcess)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_IsInputFocusCapturedByAnotherProcess();
    check_ptr_parameter("IVRSystem_011_IsInputFocusCapturedByAnotherProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_011_DriverDebugRequest, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_011_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_DriverDebugRequest(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRSystem_011_DriverDebugRequest", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_DriverDebugRequest", 1);
    check_ptr_parameter("IVRSystem_011_DriverDebugRequest", (void *)2);
    check_ptr_parameter("IVRSystem_011_DriverDebugRequest", (void *)3);
    check_uint32_parameter("IVRSystem_011_DriverDebugRequest", 4);

    init_thunk(t, this_ptr_value, IVRSystem_011_PerformFirmwareUpdate, 1, FALSE, FALSE);
    EVRFirmwareError (__stdcall *capi_IVRSystem_011_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_011_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_011_AcknowledgeQuit_Exiting)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_AcknowledgeQuit_Exiting();
    check_ptr_parameter("IVRSystem_011_AcknowledgeQuit_Exiting", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_011_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_011_AcknowledgeQuit_UserPrompt)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_AcknowledgeQuit_UserPrompt();
    check_ptr_parameter("IVRSystem_011_AcknowledgeQuit_UserPrompt", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_011_PerformanceTestEnableCapture, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_011_PerformanceTestEnableCapture)(bool bEnable) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_PerformanceTestEnableCapture(1);
    check_ptr_parameter("IVRSystem_011_PerformanceTestEnableCapture", this_ptr_value);
    check_bool_parameter("IVRSystem_011_PerformanceTestEnableCapture", 1);

    init_thunk(t, this_ptr_value, IVRSystem_011_PerformanceTestReportFidelityLevelChange, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_011_PerformanceTestReportFidelityLevelChange)(int nFidelityLevel) = (void *)t;

    clear_parameters();
    capi_IVRSystem_011_PerformanceTestReportFidelityLevelChange(1);
    check_ptr_parameter("IVRSystem_011_PerformanceTestReportFidelityLevelChange", this_ptr_value);
    check_uint32_parameter("IVRSystem_011_PerformanceTestReportFidelityLevelChange", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRApplications_004(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRApplications_004_AddApplicationManifest, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_004_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_AddApplicationManifest((void *)1, 1);
    check_ptr_parameter("IVRApplications_004_AddApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_AddApplicationManifest", (void *)1);
    check_bool_parameter("IVRApplications_004_AddApplicationManifest", 1);

    init_thunk(t, this_ptr_value, IVRApplications_004_RemoveApplicationManifest, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_004_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_RemoveApplicationManifest((void *)1);
    check_ptr_parameter("IVRApplications_004_RemoveApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_RemoveApplicationManifest", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_004_IsApplicationInstalled, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_004_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_IsApplicationInstalled((void *)1);
    check_ptr_parameter("IVRApplications_004_IsApplicationInstalled", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_IsApplicationInstalled", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_004_GetApplicationCount)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_GetApplicationCount();
    check_ptr_parameter("IVRApplications_004_GetApplicationCount", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationKeyByIndex, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_004_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_GetApplicationKeyByIndex(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_004_GetApplicationKeyByIndex", this_ptr_value);
    check_uint32_parameter("IVRApplications_004_GetApplicationKeyByIndex", 1);
    check_ptr_parameter("IVRApplications_004_GetApplicationKeyByIndex", (void *)2);
    check_uint32_parameter("IVRApplications_004_GetApplicationKeyByIndex", 3);

    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_004_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_GetApplicationKeyByProcessId(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_004_GetApplicationKeyByProcessId", this_ptr_value);
    check_uint32_parameter("IVRApplications_004_GetApplicationKeyByProcessId", 1);
    check_ptr_parameter("IVRApplications_004_GetApplicationKeyByProcessId", (void *)2);
    check_uint32_parameter("IVRApplications_004_GetApplicationKeyByProcessId", 3);

    init_thunk(t, this_ptr_value, IVRApplications_004_LaunchApplication, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_004_LaunchApplication)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_LaunchApplication((void *)1);
    check_ptr_parameter("IVRApplications_004_LaunchApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_LaunchApplication", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_004_LaunchDashboardOverlay, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_004_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_LaunchDashboardOverlay((void *)1);
    check_ptr_parameter("IVRApplications_004_LaunchDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_LaunchDashboardOverlay", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_004_CancelApplicationLaunch, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_004_CancelApplicationLaunch)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_CancelApplicationLaunch((void *)1);
    check_ptr_parameter("IVRApplications_004_CancelApplicationLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_CancelApplicationLaunch", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_004_IdentifyApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_004_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_IdentifyApplication(1, (void *)2);
    check_ptr_parameter("IVRApplications_004_IdentifyApplication", this_ptr_value);
    check_uint32_parameter("IVRApplications_004_IdentifyApplication", 1);
    check_ptr_parameter("IVRApplications_004_IdentifyApplication", (void *)2);

    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationProcessId, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_004_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_GetApplicationProcessId((void *)1);
    check_ptr_parameter("IVRApplications_004_GetApplicationProcessId", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_GetApplicationProcessId", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_004_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_GetApplicationsErrorNameFromEnum(1);
    check_ptr_parameter("IVRApplications_004_GetApplicationsErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_004_GetApplicationsErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationPropertyString, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_004_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyString", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyString", (void *)1);
    check_uint32_parameter("IVRApplications_004_GetApplicationPropertyString", 2);
    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyString", (void *)3);
    check_uint32_parameter("IVRApplications_004_GetApplicationPropertyString", 4);
    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyString", (void *)5);

    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationPropertyBool, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_004_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_GetApplicationPropertyBool((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyBool", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyBool", (void *)1);
    check_uint32_parameter("IVRApplications_004_GetApplicationPropertyBool", 2);
    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyBool", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationPropertyUint64, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRApplications_004_GetApplicationPropertyUint64)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_GetApplicationPropertyUint64((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyUint64", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyUint64", (void *)1);
    check_uint32_parameter("IVRApplications_004_GetApplicationPropertyUint64", 2);
    check_ptr_parameter("IVRApplications_004_GetApplicationPropertyUint64", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_004_SetApplicationAutoLaunch, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_004_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_SetApplicationAutoLaunch((void *)1, 1);
    check_ptr_parameter("IVRApplications_004_SetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_SetApplicationAutoLaunch", (void *)1);
    check_bool_parameter("IVRApplications_004_SetApplicationAutoLaunch", 1);

    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationAutoLaunch, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_004_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_GetApplicationAutoLaunch((void *)1);
    check_ptr_parameter("IVRApplications_004_GetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_GetApplicationAutoLaunch", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_004_GetStartingApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_004_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_GetStartingApplication((void *)1, 2);
    check_ptr_parameter("IVRApplications_004_GetStartingApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_GetStartingApplication", (void *)1);
    check_uint32_parameter("IVRApplications_004_GetStartingApplication", 2);

    init_thunk(t, this_ptr_value, IVRApplications_004_GetTransitionState, 0, FALSE, FALSE);
    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_004_GetTransitionState)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_GetTransitionState();
    check_ptr_parameter("IVRApplications_004_GetTransitionState", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_004_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_004_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_PerformApplicationPrelaunchCheck((void *)1);
    check_ptr_parameter("IVRApplications_004_PerformApplicationPrelaunchCheck", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_PerformApplicationPrelaunchCheck", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_004_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_004_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_GetApplicationsTransitionStateNameFromEnum(1);
    check_ptr_parameter("IVRApplications_004_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_004_GetApplicationsTransitionStateNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_004_IsQuitUserPromptRequested, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_004_IsQuitUserPromptRequested)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_IsQuitUserPromptRequested();
    check_ptr_parameter("IVRApplications_004_IsQuitUserPromptRequested", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_004_LaunchInternalProcess, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_004_LaunchInternalProcess)(const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory) = (void *)t;

    clear_parameters();
    capi_IVRApplications_004_LaunchInternalProcess((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRApplications_004_LaunchInternalProcess", this_ptr_value);
    check_ptr_parameter("IVRApplications_004_LaunchInternalProcess", (void *)1);
    check_ptr_parameter("IVRApplications_004_LaunchInternalProcess", (void *)2);
    check_ptr_parameter("IVRApplications_004_LaunchInternalProcess", (void *)3);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_010(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_010_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_010_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_010_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_010_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_010_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_010_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_010_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_010_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_010_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_010_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetHighQualityOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_010_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_010_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_010_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_010_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_010_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_010_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_010_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_010_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_010_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_010_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_010_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_010_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_010_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_010_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_010_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_010_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_010_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_010_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_010_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_010_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_010_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_010_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_010_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_010_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_010_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_010_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_010_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_010_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_010_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_010_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_010_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_010_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_010_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_010_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_010_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_010_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_010_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_010_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_010_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_010_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_010_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_010_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_010_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_010_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_010_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceComponent", 1);
    check_uint32_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceComponent", 2);
    check_ptr_parameter("IVROverlay_010_SetOverlayTransformTrackedDeviceComponent", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceComponent", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceComponent", (void *)2);
    check_ptr_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceComponent", (void *)3);
    check_uint32_parameter("IVROverlay_010_GetOverlayTransformTrackedDeviceComponent", 4);

    init_thunk(t, this_ptr_value, IVROverlay_010_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_010_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_010_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_HideOverlay(1);
    check_ptr_parameter("IVROverlay_010_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_010_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_010_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_010_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_010_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_010_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_010_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_010_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_010_PollNextOverlayEvent, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_010_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_PollNextOverlayEvent(1, (void *)2, 3);
    check_ptr_parameter("IVROverlay_010_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_010_PollNextOverlayEvent", (void *)2);
    check_uint32_parameter("IVROverlay_010_PollNextOverlayEvent", 3);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_010_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_010_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_010_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_010_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_010_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_010_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_010_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_010_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_010_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_010_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_010_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_010_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_010_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_010_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_010_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetGamepadFocusOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_010_GetGamepadFocusOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetGamepadFocusOverlay();
    check_ptr_parameter("IVROverlay_010_GetGamepadFocusOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetGamepadFocusOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetGamepadFocusOverlay(1);
    check_ptr_parameter("IVROverlay_010_SetGamepadFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetGamepadFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayNeighbor, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayNeighbor(1, 2, 3);
    check_ptr_parameter("IVROverlay_010_SetOverlayNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_010_SetOverlayNeighbor", 1);
    check_uint64_parameter("IVROverlay_010_SetOverlayNeighbor", 2);
    check_uint64_parameter("IVROverlay_010_SetOverlayNeighbor", 3);

    init_thunk(t, this_ptr_value, IVROverlay_010_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_MoveGamepadFocusToNeighbor(1, 2);
    check_ptr_parameter("IVROverlay_010_MoveGamepadFocusToNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_010_MoveGamepadFocusToNeighbor", 1);
    check_uint64_parameter("IVROverlay_010_MoveGamepadFocusToNeighbor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_010_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_010_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_010_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_010_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_010_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_010_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_010_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_010_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_010_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_010_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_010_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_010_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_010_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_010_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_010_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_010_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_010_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_010_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_010_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_010_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_010_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_010_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_010_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_010_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_010_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_010_GetPrimaryDashboardDevice)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetPrimaryDashboardDevice();
    check_ptr_parameter("IVROverlay_010_GetPrimaryDashboardDevice", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_010_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_010_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_010_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_010_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_010_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_010_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_010_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_010_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_010_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_010_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_010_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_010_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_010_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_010_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_010_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_010_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_010_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_010_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_010_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_010_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_010_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_010_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_010_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_010_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_010_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_010_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_HideKeyboard();
    check_ptr_parameter("IVROverlay_010_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_010_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_010_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_010_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_010_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_010_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_010_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_010_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_010_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_010_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_010_SetKeyboardPositionForOverlay", DEFAULT_RECT);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRRenderModels_004(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_LoadRenderModel_Async, 2, FALSE, FALSE);
    EVRRenderModelError (__stdcall *capi_IVRRenderModels_004_LoadRenderModel_Async)(const char * pchRenderModelName, RenderModel_t ** ppRenderModel) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_LoadRenderModel_Async((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_004_LoadRenderModel_Async", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_004_LoadRenderModel_Async", (void *)1);
    check_ptr_parameter("IVRRenderModels_004_LoadRenderModel_Async", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_FreeRenderModel, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRRenderModels_004_FreeRenderModel)(RenderModel_t * pRenderModel) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_FreeRenderModel((void *)1);
    check_ptr_parameter("IVRRenderModels_004_FreeRenderModel", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_004_FreeRenderModel", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_LoadTexture_Async, 2, FALSE, FALSE);
    EVRRenderModelError (__stdcall *capi_IVRRenderModels_004_LoadTexture_Async)(TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_LoadTexture_Async(1, (void *)2);
    check_ptr_parameter("IVRRenderModels_004_LoadTexture_Async", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_004_LoadTexture_Async", 1);
    check_ptr_parameter("IVRRenderModels_004_LoadTexture_Async", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_FreeTexture, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRRenderModels_004_FreeTexture)(RenderModel_TextureMap_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_FreeTexture((void *)1);
    check_ptr_parameter("IVRRenderModels_004_FreeTexture", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_004_FreeTexture", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_LoadTextureD3D11_Async, 3, FALSE, FALSE);
    EVRRenderModelError (__stdcall *capi_IVRRenderModels_004_LoadTextureD3D11_Async)(TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_LoadTextureD3D11_Async(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRRenderModels_004_LoadTextureD3D11_Async", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_004_LoadTextureD3D11_Async", 1);
    check_ptr_parameter("IVRRenderModels_004_LoadTextureD3D11_Async", (void *)2);
    check_ptr_parameter("IVRRenderModels_004_LoadTextureD3D11_Async", (void *)3);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_FreeTextureD3D11, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRRenderModels_004_FreeTextureD3D11)(void * pD3D11Texture2D) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_FreeTextureD3D11((void *)1);
    check_ptr_parameter("IVRRenderModels_004_FreeTextureD3D11", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_004_FreeTextureD3D11", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetRenderModelName, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_004_GetRenderModelName)(uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_GetRenderModelName(1, (void *)2, 3);
    check_ptr_parameter("IVRRenderModels_004_GetRenderModelName", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_004_GetRenderModelName", 1);
    check_ptr_parameter("IVRRenderModels_004_GetRenderModelName", (void *)2);
    check_uint32_parameter("IVRRenderModels_004_GetRenderModelName", 3);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetRenderModelCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_004_GetRenderModelCount)() = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_GetRenderModelCount();
    check_ptr_parameter("IVRRenderModels_004_GetRenderModelCount", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetComponentCount, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_004_GetComponentCount)(const char * pchRenderModelName) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_GetComponentCount((void *)1);
    check_ptr_parameter("IVRRenderModels_004_GetComponentCount", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_004_GetComponentCount", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetComponentName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_004_GetComponentName)(const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_GetComponentName((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRRenderModels_004_GetComponentName", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_004_GetComponentName", (void *)1);
    check_uint32_parameter("IVRRenderModels_004_GetComponentName", 2);
    check_ptr_parameter("IVRRenderModels_004_GetComponentName", (void *)3);
    check_uint32_parameter("IVRRenderModels_004_GetComponentName", 4);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetComponentButtonMask, 2, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRRenderModels_004_GetComponentButtonMask)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_GetComponentButtonMask((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_004_GetComponentButtonMask", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_004_GetComponentButtonMask", (void *)1);
    check_ptr_parameter("IVRRenderModels_004_GetComponentButtonMask", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetComponentRenderModelName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_004_GetComponentRenderModelName)(const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_GetComponentRenderModelName((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRRenderModels_004_GetComponentRenderModelName", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_004_GetComponentRenderModelName", (void *)1);
    check_ptr_parameter("IVRRenderModels_004_GetComponentRenderModelName", (void *)2);
    check_ptr_parameter("IVRRenderModels_004_GetComponentRenderModelName", (void *)3);
    check_uint32_parameter("IVRRenderModels_004_GetComponentRenderModelName", 4);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_GetComponentState, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRRenderModels_004_GetComponentState)(const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_GetComponentState((void *)1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRRenderModels_004_GetComponentState", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_004_GetComponentState", (void *)1);
    check_ptr_parameter("IVRRenderModels_004_GetComponentState", (void *)2);
    check_ptr_parameter("IVRRenderModels_004_GetComponentState", (void *)3);
    check_ptr_parameter("IVRRenderModels_004_GetComponentState", (void *)4);
    check_ptr_parameter("IVRRenderModels_004_GetComponentState", (void *)5);

    init_thunk(t, this_ptr_value, IVRRenderModels_004_RenderModelHasComponent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRRenderModels_004_RenderModelHasComponent)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_004_RenderModelHasComponent((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_004_RenderModelHasComponent", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_004_RenderModelHasComponent", (void *)1);
    check_ptr_parameter("IVRRenderModels_004_RenderModelHasComponent", (void *)2);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_012(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_012_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_012_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_012_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_012_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_012_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_012_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_012_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_012_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_012_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_012_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_012_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_012_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_012_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_012_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_012_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_012_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_012_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_012_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_012_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_012_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_012_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_012_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_012_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRCompositor_012_GetLastPoseForTrackedDeviceIndex", 1);
    check_ptr_parameter("IVRCompositor_012_GetLastPoseForTrackedDeviceIndex", (void *)2);
    check_ptr_parameter("IVRCompositor_012_GetLastPoseForTrackedDeviceIndex", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_012_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_012_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_012_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_012_Submit", 1);
    check_ptr_parameter("IVRCompositor_012_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_012_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_012_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_012_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_012_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_012_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_012_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_012_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_012_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_012_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_012_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_012_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_012_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_012_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_012_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_012_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_012_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_012_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_012_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_012_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_012_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_012_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_012_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_012_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_012_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_012_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_012_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_012_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_012_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_012_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_012_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_012_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_012_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_012_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_012_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_012_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_012_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_012_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_012_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_012_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_012_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_CompositorQuit();
    check_ptr_parameter("IVRCompositor_012_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_012_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_IsFullscreen();
    check_ptr_parameter("IVRCompositor_012_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_012_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_012_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_012_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_012_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_012_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_CanRenderScene();
    check_ptr_parameter("IVRCompositor_012_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_012_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_012_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_012_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_012_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_012_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_012_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_012_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_012_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_012_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_012_ShouldAppRenderWithLowResources)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_012_ShouldAppRenderWithLowResources();
    check_ptr_parameter("IVRCompositor_012_ShouldAppRenderWithLowResources", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRApplications_003(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRApplications_003_AddApplicationManifest, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_003_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_AddApplicationManifest((void *)1, 1);
    check_ptr_parameter("IVRApplications_003_AddApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_AddApplicationManifest", (void *)1);
    check_bool_parameter("IVRApplications_003_AddApplicationManifest", 1);

    init_thunk(t, this_ptr_value, IVRApplications_003_RemoveApplicationManifest, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_003_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_RemoveApplicationManifest((void *)1);
    check_ptr_parameter("IVRApplications_003_RemoveApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_RemoveApplicationManifest", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_003_IsApplicationInstalled, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_003_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_IsApplicationInstalled((void *)1);
    check_ptr_parameter("IVRApplications_003_IsApplicationInstalled", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_IsApplicationInstalled", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_003_GetApplicationCount)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_GetApplicationCount();
    check_ptr_parameter("IVRApplications_003_GetApplicationCount", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationKeyByIndex, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_003_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_GetApplicationKeyByIndex(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_003_GetApplicationKeyByIndex", this_ptr_value);
    check_uint32_parameter("IVRApplications_003_GetApplicationKeyByIndex", 1);
    check_ptr_parameter("IVRApplications_003_GetApplicationKeyByIndex", (void *)2);
    check_uint32_parameter("IVRApplications_003_GetApplicationKeyByIndex", 3);

    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_003_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_GetApplicationKeyByProcessId(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_003_GetApplicationKeyByProcessId", this_ptr_value);
    check_uint32_parameter("IVRApplications_003_GetApplicationKeyByProcessId", 1);
    check_ptr_parameter("IVRApplications_003_GetApplicationKeyByProcessId", (void *)2);
    check_uint32_parameter("IVRApplications_003_GetApplicationKeyByProcessId", 3);

    init_thunk(t, this_ptr_value, IVRApplications_003_LaunchApplication, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_003_LaunchApplication)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_LaunchApplication((void *)1);
    check_ptr_parameter("IVRApplications_003_LaunchApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_LaunchApplication", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_003_LaunchDashboardOverlay, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_003_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_LaunchDashboardOverlay((void *)1);
    check_ptr_parameter("IVRApplications_003_LaunchDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_LaunchDashboardOverlay", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_003_IdentifyApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_003_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_IdentifyApplication(1, (void *)2);
    check_ptr_parameter("IVRApplications_003_IdentifyApplication", this_ptr_value);
    check_uint32_parameter("IVRApplications_003_IdentifyApplication", 1);
    check_ptr_parameter("IVRApplications_003_IdentifyApplication", (void *)2);

    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationProcessId, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_003_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_GetApplicationProcessId((void *)1);
    check_ptr_parameter("IVRApplications_003_GetApplicationProcessId", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_GetApplicationProcessId", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_003_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_GetApplicationsErrorNameFromEnum(1);
    check_ptr_parameter("IVRApplications_003_GetApplicationsErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_003_GetApplicationsErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationPropertyString, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_003_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyString", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyString", (void *)1);
    check_uint32_parameter("IVRApplications_003_GetApplicationPropertyString", 2);
    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyString", (void *)3);
    check_uint32_parameter("IVRApplications_003_GetApplicationPropertyString", 4);
    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyString", (void *)5);

    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationPropertyBool, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_003_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_GetApplicationPropertyBool((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyBool", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyBool", (void *)1);
    check_uint32_parameter("IVRApplications_003_GetApplicationPropertyBool", 2);
    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyBool", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationPropertyUint64, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRApplications_003_GetApplicationPropertyUint64)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_GetApplicationPropertyUint64((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyUint64", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyUint64", (void *)1);
    check_uint32_parameter("IVRApplications_003_GetApplicationPropertyUint64", 2);
    check_ptr_parameter("IVRApplications_003_GetApplicationPropertyUint64", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_003_SetApplicationAutoLaunch, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_003_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_SetApplicationAutoLaunch((void *)1, 1);
    check_ptr_parameter("IVRApplications_003_SetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_SetApplicationAutoLaunch", (void *)1);
    check_bool_parameter("IVRApplications_003_SetApplicationAutoLaunch", 1);

    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationAutoLaunch, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_003_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_GetApplicationAutoLaunch((void *)1);
    check_ptr_parameter("IVRApplications_003_GetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_GetApplicationAutoLaunch", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_003_GetStartingApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_003_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_GetStartingApplication((void *)1, 2);
    check_ptr_parameter("IVRApplications_003_GetStartingApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_GetStartingApplication", (void *)1);
    check_uint32_parameter("IVRApplications_003_GetStartingApplication", 2);

    init_thunk(t, this_ptr_value, IVRApplications_003_GetTransitionState, 0, FALSE, FALSE);
    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_003_GetTransitionState)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_GetTransitionState();
    check_ptr_parameter("IVRApplications_003_GetTransitionState", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_003_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_003_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_PerformApplicationPrelaunchCheck((void *)1);
    check_ptr_parameter("IVRApplications_003_PerformApplicationPrelaunchCheck", this_ptr_value);
    check_ptr_parameter("IVRApplications_003_PerformApplicationPrelaunchCheck", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_003_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_003_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_GetApplicationsTransitionStateNameFromEnum(1);
    check_ptr_parameter("IVRApplications_003_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_003_GetApplicationsTransitionStateNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_003_IsQuitUserPromptRequested, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_003_IsQuitUserPromptRequested)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_003_IsQuitUserPromptRequested();
    check_ptr_parameter("IVRApplications_003_IsQuitUserPromptRequested", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_011(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_011_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_011_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_011_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_011_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_011_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_011_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_011_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_011_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_011_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_011_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_011_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_011_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_011_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_011_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_011_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_011_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_011_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_011_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_011_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_011_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_011_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_011_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_011_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_011_Submit", 1);
    check_ptr_parameter("IVRCompositor_011_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_011_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_011_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_011_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_011_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_011_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_011_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_011_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_011_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_011_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_011_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_011_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_011_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_011_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_011_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_011_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_011_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_011_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_011_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_011_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_011_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_011_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_011_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_011_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_011_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_011_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_011_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_011_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_011_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_011_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_011_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_011_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_011_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_011_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_011_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_011_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_011_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_011_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_011_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_011_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_011_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_CompositorQuit();
    check_ptr_parameter("IVRCompositor_011_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_011_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_IsFullscreen();
    check_ptr_parameter("IVRCompositor_011_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_011_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_011_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_011_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_011_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_011_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_CanRenderScene();
    check_ptr_parameter("IVRCompositor_011_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_011_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_011_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_011_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_011_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_011_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_011_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_011_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_011_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_011_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_011_CompositorDumpImages", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRRenderModels_002(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRRenderModels_002_LoadRenderModel, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRRenderModels_002_LoadRenderModel)(const char * pchRenderModelName, RenderModel_t ** ppRenderModel) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_002_LoadRenderModel((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_002_LoadRenderModel", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_002_LoadRenderModel", (void *)1);
    check_ptr_parameter("IVRRenderModels_002_LoadRenderModel", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_002_FreeRenderModel, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRRenderModels_002_FreeRenderModel)(RenderModel_t * pRenderModel) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_002_FreeRenderModel((void *)1);
    check_ptr_parameter("IVRRenderModels_002_FreeRenderModel", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_002_FreeRenderModel", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_002_LoadTexture, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRRenderModels_002_LoadTexture)(TextureID_t textureId, RenderModel_TextureMap_t ** ppTexture) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_002_LoadTexture(1, (void *)2);
    check_ptr_parameter("IVRRenderModels_002_LoadTexture", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_002_LoadTexture", 1);
    check_ptr_parameter("IVRRenderModels_002_LoadTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_002_FreeTexture, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRRenderModels_002_FreeTexture)(RenderModel_TextureMap_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_002_FreeTexture((void *)1);
    check_ptr_parameter("IVRRenderModels_002_FreeTexture", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_002_FreeTexture", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetRenderModelName, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_002_GetRenderModelName)(uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_002_GetRenderModelName(1, (void *)2, 3);
    check_ptr_parameter("IVRRenderModels_002_GetRenderModelName", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_002_GetRenderModelName", 1);
    check_ptr_parameter("IVRRenderModels_002_GetRenderModelName", (void *)2);
    check_uint32_parameter("IVRRenderModels_002_GetRenderModelName", 3);

    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetRenderModelCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_002_GetRenderModelCount)() = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_002_GetRenderModelCount();
    check_ptr_parameter("IVRRenderModels_002_GetRenderModelCount", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetComponentCount, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_002_GetComponentCount)(const char * pchRenderModelName) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_002_GetComponentCount((void *)1);
    check_ptr_parameter("IVRRenderModels_002_GetComponentCount", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_002_GetComponentCount", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetComponentName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_002_GetComponentName)(const char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_002_GetComponentName((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRRenderModels_002_GetComponentName", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_002_GetComponentName", (void *)1);
    check_uint32_parameter("IVRRenderModels_002_GetComponentName", 2);
    check_ptr_parameter("IVRRenderModels_002_GetComponentName", (void *)3);
    check_uint32_parameter("IVRRenderModels_002_GetComponentName", 4);

    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetComponentButtonMask, 2, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRRenderModels_002_GetComponentButtonMask)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_002_GetComponentButtonMask((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_002_GetComponentButtonMask", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_002_GetComponentButtonMask", (void *)1);
    check_ptr_parameter("IVRRenderModels_002_GetComponentButtonMask", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetComponentRenderModelName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_002_GetComponentRenderModelName)(const char * pchRenderModelName, const char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_002_GetComponentRenderModelName((void *)1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRRenderModels_002_GetComponentRenderModelName", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_002_GetComponentRenderModelName", (void *)1);
    check_ptr_parameter("IVRRenderModels_002_GetComponentRenderModelName", (void *)2);
    check_ptr_parameter("IVRRenderModels_002_GetComponentRenderModelName", (void *)3);
    check_uint32_parameter("IVRRenderModels_002_GetComponentRenderModelName", 4);

    init_thunk(t, this_ptr_value, IVRRenderModels_002_GetComponentState, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRRenderModels_002_GetComponentState)(const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ComponentState_t * pComponentState) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_002_GetComponentState((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVRRenderModels_002_GetComponentState", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_002_GetComponentState", (void *)1);
    check_ptr_parameter("IVRRenderModels_002_GetComponentState", (void *)2);
    check_ptr_parameter("IVRRenderModels_002_GetComponentState", (void *)3);
    check_ptr_parameter("IVRRenderModels_002_GetComponentState", (void *)4);

    init_thunk(t, this_ptr_value, IVRRenderModels_002_RenderModelHasComponent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRRenderModels_002_RenderModelHasComponent)(const char * pchRenderModelName, const char * pchComponentName) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_002_RenderModelHasComponent((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_002_RenderModelHasComponent", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_002_RenderModelHasComponent", (void *)1);
    check_ptr_parameter("IVRRenderModels_002_RenderModelHasComponent", (void *)2);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_010(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_010_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_010_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_010_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_010_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetProjectionMatrix, 5, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_010_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
    check_ptr_parameter("IVRSystem_010_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_010_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_010_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_010_GetProjectionMatrix", 3.0f);
    check_uint32_parameter("IVRSystem_010_GetProjectionMatrix", 4);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_010_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_010_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_010_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_010_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_010_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_010_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_010_ComputeDistortion, 4, TRUE, TRUE);
    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_010_ComputeDistortion)(DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_010_ComputeDistortion", this_ptr_value);
    check_ptr_parameter("IVRSystem_010_ComputeDistortion", data_ptr_value);
    check_uint32_parameter("IVRSystem_010_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_010_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_010_ComputeDistortion", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_010_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_010_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_010_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_010_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_010_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_010_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_010_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_010_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_010_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetDXGIOutputInfo, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_010_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetDXGIOutputInfo((void *)1);
    check_ptr_parameter("IVRSystem_010_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_010_GetDXGIOutputInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_010_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_010_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_010_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_010_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_010_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_010_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_010_SetDisplayVisibility", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_010_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_010_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_010_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_010_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_010_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_010_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_010_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_010_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_010_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_010_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_010_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_010_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_010_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_ApplyTransform, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_010_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_ApplyTransform((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_010_ApplyTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_010_ApplyTransform", (void *)1);
    check_ptr_parameter("IVRSystem_010_ApplyTransform", (void *)2);
    check_ptr_parameter("IVRSystem_010_ApplyTransform", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_010_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetTrackedDeviceIndexForControllerRole(1);
    check_ptr_parameter("IVRSystem_010_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetTrackedDeviceIndexForControllerRole", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
    ETrackedControllerRole (__stdcall *capi_IVRSystem_010_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetControllerRoleForTrackedDeviceIndex(1);
    check_ptr_parameter("IVRSystem_010_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetControllerRoleForTrackedDeviceIndex", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetTrackedDeviceClass, 1, FALSE, FALSE);
    ETrackedDeviceClass (__stdcall *capi_IVRSystem_010_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_010_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_010_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_010_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_010_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_010_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_010_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_010_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_010_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_010_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_010_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_010_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_010_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_010_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_010_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_010_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_010_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_010_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_010_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_010_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_010_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_010_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_010_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_010_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_010_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_010_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_010_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_010_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_010_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_010_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_010_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_010_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_010_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_PollNextEvent, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_010_PollNextEvent)(VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_PollNextEvent((void *)1);
    check_ptr_parameter("IVRSystem_010_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_010_PollNextEvent", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_010_PollNextEventWithPose, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_010_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_PollNextEventWithPose(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_010_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_010_PollNextEventWithPose", (void *)2);
    check_ptr_parameter("IVRSystem_010_PollNextEventWithPose", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_010_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_010_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetHiddenAreaMesh, 2, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_010_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetHiddenAreaMesh(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_010_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_010_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetHiddenAreaMesh", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetControllerState, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_010_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetControllerState(1, (void *)2);
    check_ptr_parameter("IVRSystem_010_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_010_GetControllerState", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetControllerStateWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_010_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSystem_010_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_010_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_010_GetControllerStateWithPose", (void *)3);
    check_ptr_parameter("IVRSystem_010_GetControllerStateWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_010_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_010_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_010_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_010_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_010_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_010_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_010_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_010_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_010_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_CaptureInputFocus, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_010_CaptureInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_CaptureInputFocus();
    check_ptr_parameter("IVRSystem_010_CaptureInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_010_ReleaseInputFocus, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_010_ReleaseInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_ReleaseInputFocus();
    check_ptr_parameter("IVRSystem_010_ReleaseInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_010_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_010_IsInputFocusCapturedByAnotherProcess)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_IsInputFocusCapturedByAnotherProcess();
    check_ptr_parameter("IVRSystem_010_IsInputFocusCapturedByAnotherProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_010_DriverDebugRequest, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_010_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_DriverDebugRequest(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRSystem_010_DriverDebugRequest", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_DriverDebugRequest", 1);
    check_ptr_parameter("IVRSystem_010_DriverDebugRequest", (void *)2);
    check_ptr_parameter("IVRSystem_010_DriverDebugRequest", (void *)3);
    check_uint32_parameter("IVRSystem_010_DriverDebugRequest", 4);

    init_thunk(t, this_ptr_value, IVRSystem_010_PerformFirmwareUpdate, 1, FALSE, FALSE);
    EVRFirmwareError (__stdcall *capi_IVRSystem_010_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_010_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_010_AcknowledgeQuit_Exiting)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_AcknowledgeQuit_Exiting();
    check_ptr_parameter("IVRSystem_010_AcknowledgeQuit_Exiting", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_010_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_010_AcknowledgeQuit_UserPrompt)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_AcknowledgeQuit_UserPrompt();
    check_ptr_parameter("IVRSystem_010_AcknowledgeQuit_UserPrompt", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_010_PerformanceTestEnableCapture, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_010_PerformanceTestEnableCapture)(bool bEnable) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_PerformanceTestEnableCapture(1);
    check_ptr_parameter("IVRSystem_010_PerformanceTestEnableCapture", this_ptr_value);
    check_bool_parameter("IVRSystem_010_PerformanceTestEnableCapture", 1);

    init_thunk(t, this_ptr_value, IVRSystem_010_PerformanceTestReportFidelityLevelChange, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_010_PerformanceTestReportFidelityLevelChange)(int nFidelityLevel) = (void *)t;

    clear_parameters();
    capi_IVRSystem_010_PerformanceTestReportFidelityLevelChange(1);
    check_ptr_parameter("IVRSystem_010_PerformanceTestReportFidelityLevelChange", this_ptr_value);
    check_uint32_parameter("IVRSystem_010_PerformanceTestReportFidelityLevelChange", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRApplications_002(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRApplications_002_AddApplicationManifest, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_002_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_AddApplicationManifest((void *)1, 1);
    check_ptr_parameter("IVRApplications_002_AddApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_002_AddApplicationManifest", (void *)1);
    check_bool_parameter("IVRApplications_002_AddApplicationManifest", 1);

    init_thunk(t, this_ptr_value, IVRApplications_002_RemoveApplicationManifest, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_002_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_RemoveApplicationManifest((void *)1);
    check_ptr_parameter("IVRApplications_002_RemoveApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_002_RemoveApplicationManifest", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_002_IsApplicationInstalled, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_002_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_IsApplicationInstalled((void *)1);
    check_ptr_parameter("IVRApplications_002_IsApplicationInstalled", this_ptr_value);
    check_ptr_parameter("IVRApplications_002_IsApplicationInstalled", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_002_GetApplicationCount)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_GetApplicationCount();
    check_ptr_parameter("IVRApplications_002_GetApplicationCount", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationKeyByIndex, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_002_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_GetApplicationKeyByIndex(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_002_GetApplicationKeyByIndex", this_ptr_value);
    check_uint32_parameter("IVRApplications_002_GetApplicationKeyByIndex", 1);
    check_ptr_parameter("IVRApplications_002_GetApplicationKeyByIndex", (void *)2);
    check_uint32_parameter("IVRApplications_002_GetApplicationKeyByIndex", 3);

    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_002_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_GetApplicationKeyByProcessId(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_002_GetApplicationKeyByProcessId", this_ptr_value);
    check_uint32_parameter("IVRApplications_002_GetApplicationKeyByProcessId", 1);
    check_ptr_parameter("IVRApplications_002_GetApplicationKeyByProcessId", (void *)2);
    check_uint32_parameter("IVRApplications_002_GetApplicationKeyByProcessId", 3);

    init_thunk(t, this_ptr_value, IVRApplications_002_LaunchApplication, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_002_LaunchApplication)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_LaunchApplication((void *)1);
    check_ptr_parameter("IVRApplications_002_LaunchApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_002_LaunchApplication", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_002_LaunchDashboardOverlay, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_002_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_LaunchDashboardOverlay((void *)1);
    check_ptr_parameter("IVRApplications_002_LaunchDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVRApplications_002_LaunchDashboardOverlay", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_002_IdentifyApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_002_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_IdentifyApplication(1, (void *)2);
    check_ptr_parameter("IVRApplications_002_IdentifyApplication", this_ptr_value);
    check_uint32_parameter("IVRApplications_002_IdentifyApplication", 1);
    check_ptr_parameter("IVRApplications_002_IdentifyApplication", (void *)2);

    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationProcessId, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_002_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_GetApplicationProcessId((void *)1);
    check_ptr_parameter("IVRApplications_002_GetApplicationProcessId", this_ptr_value);
    check_ptr_parameter("IVRApplications_002_GetApplicationProcessId", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_002_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_GetApplicationsErrorNameFromEnum(1);
    check_ptr_parameter("IVRApplications_002_GetApplicationsErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_002_GetApplicationsErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationPropertyString, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_002_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyString", this_ptr_value);
    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyString", (void *)1);
    check_uint32_parameter("IVRApplications_002_GetApplicationPropertyString", 2);
    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyString", (void *)3);
    check_uint32_parameter("IVRApplications_002_GetApplicationPropertyString", 4);
    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyString", (void *)5);

    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationPropertyBool, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_002_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_GetApplicationPropertyBool((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyBool", this_ptr_value);
    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyBool", (void *)1);
    check_uint32_parameter("IVRApplications_002_GetApplicationPropertyBool", 2);
    check_ptr_parameter("IVRApplications_002_GetApplicationPropertyBool", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_002_SetApplicationAutoLaunch, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_002_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_SetApplicationAutoLaunch((void *)1, 1);
    check_ptr_parameter("IVRApplications_002_SetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_002_SetApplicationAutoLaunch", (void *)1);
    check_bool_parameter("IVRApplications_002_SetApplicationAutoLaunch", 1);

    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationAutoLaunch, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_002_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_GetApplicationAutoLaunch((void *)1);
    check_ptr_parameter("IVRApplications_002_GetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_002_GetApplicationAutoLaunch", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_002_GetStartingApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_002_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_GetStartingApplication((void *)1, 2);
    check_ptr_parameter("IVRApplications_002_GetStartingApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_002_GetStartingApplication", (void *)1);
    check_uint32_parameter("IVRApplications_002_GetStartingApplication", 2);

    init_thunk(t, this_ptr_value, IVRApplications_002_GetTransitionState, 0, FALSE, FALSE);
    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_002_GetTransitionState)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_GetTransitionState();
    check_ptr_parameter("IVRApplications_002_GetTransitionState", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_002_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_002_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_PerformApplicationPrelaunchCheck((void *)1);
    check_ptr_parameter("IVRApplications_002_PerformApplicationPrelaunchCheck", this_ptr_value);
    check_ptr_parameter("IVRApplications_002_PerformApplicationPrelaunchCheck", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_002_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_002_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_GetApplicationsTransitionStateNameFromEnum(1);
    check_ptr_parameter("IVRApplications_002_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_002_GetApplicationsTransitionStateNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_002_IsQuitUserPromptRequested, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_002_IsQuitUserPromptRequested)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_002_IsQuitUserPromptRequested();
    check_ptr_parameter("IVRApplications_002_IsQuitUserPromptRequested", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRChaperoneSetup_004(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_CommitWorkingCopy, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_004_CommitWorkingCopy)(EChaperoneConfigFile configFile) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_CommitWorkingCopy(1);
    check_ptr_parameter("IVRChaperoneSetup_004_CommitWorkingCopy", this_ptr_value);
    check_uint32_parameter("IVRChaperoneSetup_004_CommitWorkingCopy", 1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_RevertWorkingCopy, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_004_RevertWorkingCopy)() = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_RevertWorkingCopy();
    check_ptr_parameter("IVRChaperoneSetup_004_RevertWorkingCopy", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetWorkingPlayAreaSize, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_004_GetWorkingPlayAreaSize)(float * pSizeX, float * pSizeZ) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_GetWorkingPlayAreaSize((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingPlayAreaSize", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingPlayAreaSize", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingPlayAreaSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetWorkingPlayAreaRect, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_004_GetWorkingPlayAreaRect)(HmdQuad_t * rect) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_GetWorkingPlayAreaRect((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingPlayAreaRect", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingPlayAreaRect", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingCollisionBoundsInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveCollisionBoundsInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingSeatedZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatStandingZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_004_GetWorkingStandingZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_SetWorkingPlayAreaSize, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_004_SetWorkingPlayAreaSize)(float sizeX, float sizeZ) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_SetWorkingPlayAreaSize(1.0f, 2.0f);
    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingPlayAreaSize", this_ptr_value);
    check_float_parameter("IVRChaperoneSetup_004_SetWorkingPlayAreaSize", 1.0f);
    check_float_parameter("IVRChaperoneSetup_004_SetWorkingPlayAreaSize", 2.0f);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo((void *)1, 2);
    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo", (void *)1);
    check_uint32_parameter("IVRChaperoneSetup_004_SetWorkingCollisionBoundsInfo", 2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pMatSeatedZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingSeatedZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose)(HmdMatrix34_t * pMatStandingZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingStandingZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_ReloadFromDisk, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_004_ReloadFromDisk)(EChaperoneConfigFile configFile) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_ReloadFromDisk(1);
    check_ptr_parameter("IVRChaperoneSetup_004_ReloadFromDisk", this_ptr_value);
    check_uint32_parameter("IVRChaperoneSetup_004_ReloadFromDisk", 1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose)(HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose((void *)1);
    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveSeatedZeroPoseToRawTrackingPose", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_SetWorkingWallTagInfo, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperoneSetup_004_SetWorkingWallTagInfo)(uint8_t * pTagsBuffer, uint32_t unTagCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_SetWorkingWallTagInfo((void *)1, 2);
    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingWallTagInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_004_SetWorkingWallTagInfo", (void *)1);
    check_uint32_parameter("IVRChaperoneSetup_004_SetWorkingWallTagInfo", 2);

    init_thunk(t, this_ptr_value, IVRChaperoneSetup_004_GetLiveWallTagInfo, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperoneSetup_004_GetLiveWallTagInfo)(uint8_t * pTagsBuffer, uint32_t * punTagCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperoneSetup_004_GetLiveWallTagInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveWallTagInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveWallTagInfo", (void *)1);
    check_ptr_parameter("IVRChaperoneSetup_004_GetLiveWallTagInfo", (void *)2);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_010(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_010_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_010_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_010_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_010_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_010_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_010_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_010_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_010_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_010_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_010_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_010_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_010_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_010_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_010_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_010_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_010_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_010_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_010_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_010_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_010_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_010_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_010_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_010_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_010_Submit", 1);
    check_ptr_parameter("IVRCompositor_010_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_010_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_010_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_010_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_010_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_010_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_010_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_010_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_010_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_010_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_010_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_010_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_010_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_010_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_010_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_010_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_010_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_010_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_010_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_010_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_010_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_010_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_010_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_010_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_010_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_010_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_010_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_010_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_010_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_010_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_010_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_010_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_010_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_010_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_010_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_010_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_010_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_010_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_010_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_010_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_010_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_CompositorQuit();
    check_ptr_parameter("IVRCompositor_010_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_010_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_IsFullscreen();
    check_ptr_parameter("IVRCompositor_010_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_010_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_010_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_010_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_010_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_010_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_CanRenderScene();
    check_ptr_parameter("IVRCompositor_010_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_010_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_010_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_010_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_010_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_010_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_010_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_010_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_010_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_010_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_010_CompositorDumpImages", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_008(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_008_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_008_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_008_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_008_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_008_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_008_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_008_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_008_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_008_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_008_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetHighQualityOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_008_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_008_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_008_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_008_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_008_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_008_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_008_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_008_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_008_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_008_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_008_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_008_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_008_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_008_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_008_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_008_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_008_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_008_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_008_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_008_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_008_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_008_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_008_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_008_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_008_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_008_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_008_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_008_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_008_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_008_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_008_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_008_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_008_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_008_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_008_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_008_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_008_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_008_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_008_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_008_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_008_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_008_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_008_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_008_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_008_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_008_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_008_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_008_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_008_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_008_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_008_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_008_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_008_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_HideOverlay(1);
    check_ptr_parameter("IVROverlay_008_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_008_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_008_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_008_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
    check_ptr_parameter("IVROverlay_008_GetTransformForOverlayCoordinates", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetTransformForOverlayCoordinates", 1);
    check_uint32_parameter("IVROverlay_008_GetTransformForOverlayCoordinates", 2);
    check_HmdVector2_parameter("IVROverlay_008_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
    check_ptr_parameter("IVROverlay_008_GetTransformForOverlayCoordinates", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_008_PollNextOverlayEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_008_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_PollNextOverlayEvent(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_008_PollNextOverlayEvent", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_008_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_008_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_008_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_008_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_008_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_008_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_008_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_008_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_008_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_008_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_008_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_008_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_008_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_008_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_008_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetGamepadFocusOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_008_GetGamepadFocusOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetGamepadFocusOverlay();
    check_ptr_parameter("IVROverlay_008_GetGamepadFocusOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetGamepadFocusOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetGamepadFocusOverlay(1);
    check_ptr_parameter("IVROverlay_008_SetGamepadFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetGamepadFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayNeighbor, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayNeighbor(1, 2, 3);
    check_ptr_parameter("IVROverlay_008_SetOverlayNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_008_SetOverlayNeighbor", 1);
    check_uint64_parameter("IVROverlay_008_SetOverlayNeighbor", 2);
    check_uint64_parameter("IVROverlay_008_SetOverlayNeighbor", 3);

    init_thunk(t, this_ptr_value, IVROverlay_008_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_MoveGamepadFocusToNeighbor(1, 2);
    check_ptr_parameter("IVROverlay_008_MoveGamepadFocusToNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_008_MoveGamepadFocusToNeighbor", 1);
    check_uint64_parameter("IVROverlay_008_MoveGamepadFocusToNeighbor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_008_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_008_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_008_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_008_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_008_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_008_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_008_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_008_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_008_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_008_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_008_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_008_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_008_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_008_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_008_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_008_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_008_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_008_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_008_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_008_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_008_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_008_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_008_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_008_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_008_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_008_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_008_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_008_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_008_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_008_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_008_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_008_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_008_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_008_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_008_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_008_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_008_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_008_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_008_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_008_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_008_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_008_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_008_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_008_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_008_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_008_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_008_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_008_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_008_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_008_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_008_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_HideKeyboard();
    check_ptr_parameter("IVROverlay_008_HideKeyboard", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_008_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetKeyboardTransformAbsolute(1, (void *)2);
    check_ptr_parameter("IVROverlay_008_SetKeyboardTransformAbsolute", this_ptr_value);
    check_uint32_parameter("IVROverlay_008_SetKeyboardTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_008_SetKeyboardTransformAbsolute", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_008_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_008_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;

    clear_parameters();
    capi_IVROverlay_008_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
    check_ptr_parameter("IVROverlay_008_SetKeyboardPositionForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_008_SetKeyboardPositionForOverlay", 1);
    check_HmdRect2_parameter("IVROverlay_008_SetKeyboardPositionForOverlay", DEFAULT_RECT);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRTrackedCamera_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_HasCamera, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_HasCamera)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_HasCamera(1);
    check_ptr_parameter("IVRTrackedCamera_001_HasCamera", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_HasCamera", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetCameraFirmwareDescription, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_GetCameraFirmwareDescription)(TrackedDeviceIndex_t nDeviceIndex, char * pBuffer, uint32_t nBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_GetCameraFirmwareDescription(1, (void *)2, 3);
    check_ptr_parameter("IVRTrackedCamera_001_GetCameraFirmwareDescription", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_GetCameraFirmwareDescription", 1);
    check_ptr_parameter("IVRTrackedCamera_001_GetCameraFirmwareDescription", (void *)2);
    check_uint32_parameter("IVRTrackedCamera_001_GetCameraFirmwareDescription", 3);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetCameraFrameDimensions, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_GetCameraFrameDimensions)(TrackedDeviceIndex_t nDeviceIndex, ECameraVideoStreamFormat nVideoStreamFormat, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_GetCameraFrameDimensions(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRTrackedCamera_001_GetCameraFrameDimensions", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_GetCameraFrameDimensions", 1);
    check_uint32_parameter("IVRTrackedCamera_001_GetCameraFrameDimensions", 2);
    check_ptr_parameter("IVRTrackedCamera_001_GetCameraFrameDimensions", (void *)3);
    check_ptr_parameter("IVRTrackedCamera_001_GetCameraFrameDimensions", (void *)4);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_SetCameraVideoStreamFormat, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_SetCameraVideoStreamFormat)(TrackedDeviceIndex_t nDeviceIndex, ECameraVideoStreamFormat nVideoStreamFormat) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_SetCameraVideoStreamFormat(1, 2);
    check_ptr_parameter("IVRTrackedCamera_001_SetCameraVideoStreamFormat", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_SetCameraVideoStreamFormat", 1);
    check_uint32_parameter("IVRTrackedCamera_001_SetCameraVideoStreamFormat", 2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetCameraVideoStreamFormat, 1, FALSE, FALSE);
    ECameraVideoStreamFormat (__stdcall *capi_IVRTrackedCamera_001_GetCameraVideoStreamFormat)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_GetCameraVideoStreamFormat(1);
    check_ptr_parameter("IVRTrackedCamera_001_GetCameraVideoStreamFormat", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_GetCameraVideoStreamFormat", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_EnableCameraForStreaming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_EnableCameraForStreaming)(TrackedDeviceIndex_t nDeviceIndex, bool bEnable) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_EnableCameraForStreaming(1, 1);
    check_ptr_parameter("IVRTrackedCamera_001_EnableCameraForStreaming", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_EnableCameraForStreaming", 1);
    check_bool_parameter("IVRTrackedCamera_001_EnableCameraForStreaming", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_StartVideoStream, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_StartVideoStream)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_StartVideoStream(1);
    check_ptr_parameter("IVRTrackedCamera_001_StartVideoStream", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_StartVideoStream", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_StopVideoStream, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_StopVideoStream)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_StopVideoStream(1);
    check_ptr_parameter("IVRTrackedCamera_001_StopVideoStream", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_StopVideoStream", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_IsVideoStreamActive, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_IsVideoStreamActive)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_IsVideoStreamActive(1);
    check_ptr_parameter("IVRTrackedCamera_001_IsVideoStreamActive", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_IsVideoStreamActive", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetVideoStreamElapsedTime, 1, FALSE, FALSE);
    float (__stdcall *capi_IVRTrackedCamera_001_GetVideoStreamElapsedTime)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_GetVideoStreamElapsedTime(1);
    check_ptr_parameter("IVRTrackedCamera_001_GetVideoStreamElapsedTime", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_GetVideoStreamElapsedTime", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetVideoStreamFrame, 1, FALSE, FALSE);
    const CameraVideoStreamFrame_t * (__stdcall *capi_IVRTrackedCamera_001_GetVideoStreamFrame)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_GetVideoStreamFrame(1);
    check_ptr_parameter("IVRTrackedCamera_001_GetVideoStreamFrame", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_GetVideoStreamFrame", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_ReleaseVideoStreamFrame, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_ReleaseVideoStreamFrame)(TrackedDeviceIndex_t nDeviceIndex, CameraVideoStreamFrame_t * pFrameImage) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_ReleaseVideoStreamFrame(1, (void *)2);
    check_ptr_parameter("IVRTrackedCamera_001_ReleaseVideoStreamFrame", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_ReleaseVideoStreamFrame", 1);
    check_ptr_parameter("IVRTrackedCamera_001_ReleaseVideoStreamFrame", (void *)2);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_SetAutoExposure, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_SetAutoExposure)(TrackedDeviceIndex_t nDeviceIndex, bool bEnable) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_SetAutoExposure(1, 1);
    check_ptr_parameter("IVRTrackedCamera_001_SetAutoExposure", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_SetAutoExposure", 1);
    check_bool_parameter("IVRTrackedCamera_001_SetAutoExposure", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_PauseVideoStream, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_PauseVideoStream)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_PauseVideoStream(1);
    check_ptr_parameter("IVRTrackedCamera_001_PauseVideoStream", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_PauseVideoStream", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_ResumeVideoStream, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_ResumeVideoStream)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_ResumeVideoStream(1);
    check_ptr_parameter("IVRTrackedCamera_001_ResumeVideoStream", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_ResumeVideoStream", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_IsVideoStreamPaused, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_IsVideoStreamPaused)(TrackedDeviceIndex_t nDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_IsVideoStreamPaused(1);
    check_ptr_parameter("IVRTrackedCamera_001_IsVideoStreamPaused", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_IsVideoStreamPaused", 1);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetCameraDistortion, 5, TRUE, FALSE);
    bool (__stdcall *capi_IVRTrackedCamera_001_GetCameraDistortion)(TrackedDeviceIndex_t nDeviceIndex, float flInputU, float flInputV, float * pflOutputU, float * pflOutputV) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_GetCameraDistortion(1, 2.0f, 3.0f, (void *)4, (void *)5);
    check_ptr_parameter("IVRTrackedCamera_001_GetCameraDistortion", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_GetCameraDistortion", 1);
    check_float_parameter("IVRTrackedCamera_001_GetCameraDistortion", 2.0f);
    check_float_parameter("IVRTrackedCamera_001_GetCameraDistortion", 3.0f);
    check_ptr_parameter("IVRTrackedCamera_001_GetCameraDistortion", (void *)4);
    check_ptr_parameter("IVRTrackedCamera_001_GetCameraDistortion", (void *)5);

    init_thunk(t, this_ptr_value, IVRTrackedCamera_001_GetCameraProjection, 6, TRUE, TRUE);
    bool (__stdcall *capi_IVRTrackedCamera_001_GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, float flWidthPixels, float flHeightPixels, float flZNear, float flZFar, HmdMatrix44_t * pProjection) = (void *)t;

    clear_parameters();
    capi_IVRTrackedCamera_001_GetCameraProjection(1, 2.0f, 3.0f, 4.0f, 5.0f, (void *)6);
    check_ptr_parameter("IVRTrackedCamera_001_GetCameraProjection", this_ptr_value);
    check_uint32_parameter("IVRTrackedCamera_001_GetCameraProjection", 1);
    check_float_parameter("IVRTrackedCamera_001_GetCameraProjection", 2.0f);
    check_float_parameter("IVRTrackedCamera_001_GetCameraProjection", 3.0f);
    check_float_parameter("IVRTrackedCamera_001_GetCameraProjection", 4.0f);
    check_float_parameter("IVRTrackedCamera_001_GetCameraProjection", 5.0f);
    check_ptr_parameter("IVRTrackedCamera_001_GetCameraProjection", (void *)6);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_009(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_009_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_009_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_009_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_009_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_009_GetTrackingSpace, 0, FALSE, FALSE);
    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_009_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_009_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_WaitGetPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_009_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_009_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_009_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_009_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_009_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_009_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_009_GetLastPoses, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_009_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_GetLastPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_009_GetLastPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_009_GetLastPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_009_GetLastPoses", 2);
    check_ptr_parameter("IVRCompositor_009_GetLastPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_009_GetLastPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_009_Submit, 4, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_009_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_Submit(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_009_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_009_Submit", 1);
    check_ptr_parameter("IVRCompositor_009_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_009_Submit", (void *)3);
    check_uint32_parameter("IVRCompositor_009_Submit", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_009_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_009_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_009_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_PostPresentHandoff, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_009_PostPresentHandoff)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_PostPresentHandoff();
    check_ptr_parameter("IVRCompositor_009_PostPresentHandoff", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_009_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_009_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_009_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_009_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_009_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_009_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_009_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_009_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_009_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_009_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_009_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_009_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_009_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_009_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_009_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_009_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_009_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_009_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_009_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_009_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_009_SetSkyboxOverride, 2, FALSE, FALSE);
    EVRCompositorError (__stdcall *capi_IVRCompositor_009_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_SetSkyboxOverride((void *)1, 2);
    check_ptr_parameter("IVRCompositor_009_SetSkyboxOverride", this_ptr_value);
    check_ptr_parameter("IVRCompositor_009_SetSkyboxOverride", (void *)1);
    check_uint32_parameter("IVRCompositor_009_SetSkyboxOverride", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_009_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_009_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_009_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_009_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_009_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_009_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_009_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_009_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_CompositorQuit();
    check_ptr_parameter("IVRCompositor_009_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_009_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_IsFullscreen();
    check_ptr_parameter("IVRCompositor_009_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_009_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_009_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_009_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_009_GetLastFrameRenderer", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_009_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_CanRenderScene();
    check_ptr_parameter("IVRCompositor_009_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_009_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_009_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_009_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_009_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_IsMirrorWindowVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_009_IsMirrorWindowVisible)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_IsMirrorWindowVisible();
    check_ptr_parameter("IVRCompositor_009_IsMirrorWindowVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_009_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_009_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_009_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_009_CompositorDumpImages", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_009(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_009_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_009_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_009_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_009_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetProjectionMatrix, 5, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_009_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
    check_ptr_parameter("IVRSystem_009_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_009_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_009_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_009_GetProjectionMatrix", 3.0f);
    check_uint32_parameter("IVRSystem_009_GetProjectionMatrix", 4);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_009_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_009_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_009_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_009_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_009_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_009_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_009_ComputeDistortion, 4, TRUE, TRUE);
    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_009_ComputeDistortion)(DistortionCoordinates_t *_r, EVREye eEye, float fU, float fV) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_009_ComputeDistortion", this_ptr_value);
    check_ptr_parameter("IVRSystem_009_ComputeDistortion", data_ptr_value);
    check_uint32_parameter("IVRSystem_009_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_009_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_009_ComputeDistortion", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_009_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_009_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_009_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_009_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_009_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_009_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_009_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_009_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_009_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetDXGIOutputInfo, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_009_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetDXGIOutputInfo((void *)1);
    check_ptr_parameter("IVRSystem_009_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_009_GetDXGIOutputInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_009_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_009_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_009_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_009_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_009_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_009_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_009_SetDisplayVisibility", 1);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_009_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_009_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_009_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_009_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_009_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_009_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_009_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_009_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_009_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_009_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_009_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_009_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_009_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_009_ApplyTransform, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_009_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_ApplyTransform((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_009_ApplyTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_009_ApplyTransform", (void *)1);
    check_ptr_parameter("IVRSystem_009_ApplyTransform", (void *)2);
    check_ptr_parameter("IVRSystem_009_ApplyTransform", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetTrackedDeviceClass, 1, FALSE, FALSE);
    ETrackedDeviceClass (__stdcall *capi_IVRSystem_009_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_009_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_009_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_009_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_009_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_009_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_009_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_009_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_009_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_009_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_009_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_009_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_009_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_009_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_009_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_009_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_009_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_009_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_009_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_009_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_009_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_009_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_009_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_009_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_009_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_009_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_009_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_009_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_009_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_009_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_009_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_009_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_009_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_009_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_009_PollNextEvent, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_009_PollNextEvent)(VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_PollNextEvent((void *)1);
    check_ptr_parameter("IVRSystem_009_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_009_PollNextEvent", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_009_PollNextEventWithPose, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_009_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_PollNextEventWithPose(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_009_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_009_PollNextEventWithPose", (void *)2);
    check_ptr_parameter("IVRSystem_009_PollNextEventWithPose", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_009_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_009_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetHiddenAreaMesh, 2, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_009_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetHiddenAreaMesh(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_009_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_009_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetHiddenAreaMesh", 1);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetControllerState, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_009_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetControllerState(1, (void *)2);
    check_ptr_parameter("IVRSystem_009_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_009_GetControllerState", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetControllerStateWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_009_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSystem_009_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_009_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_009_GetControllerStateWithPose", (void *)3);
    check_ptr_parameter("IVRSystem_009_GetControllerStateWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_009_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_009_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_009_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_009_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_009_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_009_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_009_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_009_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_009_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_009_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_009_CaptureInputFocus, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_009_CaptureInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_CaptureInputFocus();
    check_ptr_parameter("IVRSystem_009_CaptureInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_009_ReleaseInputFocus, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_009_ReleaseInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_ReleaseInputFocus();
    check_ptr_parameter("IVRSystem_009_ReleaseInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_009_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_009_IsInputFocusCapturedByAnotherProcess)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_IsInputFocusCapturedByAnotherProcess();
    check_ptr_parameter("IVRSystem_009_IsInputFocusCapturedByAnotherProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_009_DriverDebugRequest, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_009_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_DriverDebugRequest(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRSystem_009_DriverDebugRequest", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_DriverDebugRequest", 1);
    check_ptr_parameter("IVRSystem_009_DriverDebugRequest", (void *)2);
    check_ptr_parameter("IVRSystem_009_DriverDebugRequest", (void *)3);
    check_uint32_parameter("IVRSystem_009_DriverDebugRequest", 4);

    init_thunk(t, this_ptr_value, IVRSystem_009_PerformFirmwareUpdate, 1, FALSE, FALSE);
    EVRFirmwareError (__stdcall *capi_IVRSystem_009_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_009_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_009_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_009_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_009_AcknowledgeQuit_Exiting)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_AcknowledgeQuit_Exiting();
    check_ptr_parameter("IVRSystem_009_AcknowledgeQuit_Exiting", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_009_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_009_AcknowledgeQuit_UserPrompt)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_009_AcknowledgeQuit_UserPrompt();
    check_ptr_parameter("IVRSystem_009_AcknowledgeQuit_UserPrompt", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_007(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_007_FindOverlay, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_007_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_007_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_007_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_CreateOverlay, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_007_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_007_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_007_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_007_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_007_DestroyOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_007_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetHighQualityOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_007_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_007_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_007_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_007_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_007_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_007_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_007_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_007_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_007_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_007_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_007_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayImageData, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_007_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_007_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_007_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_007_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_007_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_007_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_007_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_007_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_007_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_007_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayFlag, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_007_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_007_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_007_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayColor, 4, TRUE, TRUE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_007_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_007_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_007_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_007_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayColor, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_007_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_007_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_007_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayAlpha, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_007_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_007_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayAlpha, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_007_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_007_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_007_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_007_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayTextureColorSpace(1, 2);
    check_ptr_parameter("IVROverlay_007_SetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayTextureColorSpace", 1);
    check_uint32_parameter("IVROverlay_007_SetOverlayTextureColorSpace", 2);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayTextureColorSpace(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_GetOverlayTextureColorSpace", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayTextureColorSpace", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayTextureColorSpace", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_007_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayTextureBounds, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayTransformType, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_007_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_007_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_007_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_007_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_007_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_007_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_007_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_007_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_007_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_007_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_007_ShowOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_007_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_007_HideOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_HideOverlay(1);
    check_ptr_parameter("IVROverlay_007_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_007_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_007_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_007_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_007_PollNextOverlayEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_007_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_PollNextOverlayEvent(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_007_PollNextOverlayEvent", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayInputMethod, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_007_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_007_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_007_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayMouseScale, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_007_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_007_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_007_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_007_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_007_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_007_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_007_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_007_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_007_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_007_IsHoverTargetOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_007_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_IsHoverTargetOverlay(1);
    check_ptr_parameter("IVROverlay_007_IsHoverTargetOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_IsHoverTargetOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetGamepadFocusOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_007_GetGamepadFocusOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetGamepadFocusOverlay();
    check_ptr_parameter("IVROverlay_007_GetGamepadFocusOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetGamepadFocusOverlay, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetGamepadFocusOverlay(1);
    check_ptr_parameter("IVROverlay_007_SetGamepadFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetGamepadFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayNeighbor, 3, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayNeighbor(1, 2, 3);
    check_ptr_parameter("IVROverlay_007_SetOverlayNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_007_SetOverlayNeighbor", 1);
    check_uint64_parameter("IVROverlay_007_SetOverlayNeighbor", 2);
    check_uint64_parameter("IVROverlay_007_SetOverlayNeighbor", 3);

    init_thunk(t, this_ptr_value, IVROverlay_007_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_MoveGamepadFocusToNeighbor(1, 2);
    check_ptr_parameter("IVROverlay_007_MoveGamepadFocusToNeighbor", this_ptr_value);
    check_uint32_parameter("IVROverlay_007_MoveGamepadFocusToNeighbor", 1);
    check_uint64_parameter("IVROverlay_007_MoveGamepadFocusToNeighbor", 2);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayTexture, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_007_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_ClearOverlayTexture, 1, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_007_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayRaw, 5, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_007_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_007_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_007_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_007_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_007_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetOverlayFromFile, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_007_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_CreateDashboardOverlay, 4, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_007_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_007_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_007_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_007_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_007_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_007_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_007_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_007_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_007_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_007_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_007_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_007_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_007_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_007_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_007_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_007_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_007_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_007_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_007_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_007_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_007_ShowKeyboard, 7, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
    check_ptr_parameter("IVROverlay_007_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_007_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_007_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_007_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_007_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_007_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_007_ShowKeyboard", 1);
    check_uint64_parameter("IVROverlay_007_ShowKeyboard", 7);

    init_thunk(t, this_ptr_value, IVROverlay_007_ShowKeyboardForOverlay, 8, FALSE, FALSE);
    EVROverlayError (__stdcall *capi_IVROverlay_007_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
    check_ptr_parameter("IVROverlay_007_ShowKeyboardForOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_007_ShowKeyboardForOverlay", 1);
    check_uint32_parameter("IVROverlay_007_ShowKeyboardForOverlay", 2);
    check_uint32_parameter("IVROverlay_007_ShowKeyboardForOverlay", 3);
    check_ptr_parameter("IVROverlay_007_ShowKeyboardForOverlay", (void *)4);
    check_uint32_parameter("IVROverlay_007_ShowKeyboardForOverlay", 5);
    check_ptr_parameter("IVROverlay_007_ShowKeyboardForOverlay", (void *)6);
    check_bool_parameter("IVROverlay_007_ShowKeyboardForOverlay", 1);
    check_uint64_parameter("IVROverlay_007_ShowKeyboardForOverlay", 8);

    init_thunk(t, this_ptr_value, IVROverlay_007_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_007_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_007_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_007_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_007_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_007_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_007_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_007_HideKeyboard();
    check_ptr_parameter("IVROverlay_007_HideKeyboard", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_006(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetWindowBounds, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_006_GetWindowBounds)(int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetWindowBounds((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSystem_006_GetWindowBounds", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_GetWindowBounds", (void *)1);
    check_ptr_parameter("IVRSystem_006_GetWindowBounds", (void *)2);
    check_ptr_parameter("IVRSystem_006_GetWindowBounds", (void *)3);
    check_ptr_parameter("IVRSystem_006_GetWindowBounds", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_006_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_006_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_006_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetEyeOutputViewport, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_006_GetEyeOutputViewport)(Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetEyeOutputViewport(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_006_GetEyeOutputViewport", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetEyeOutputViewport", 1);
    check_ptr_parameter("IVRSystem_006_GetEyeOutputViewport", (void *)2);
    check_ptr_parameter("IVRSystem_006_GetEyeOutputViewport", (void *)3);
    check_ptr_parameter("IVRSystem_006_GetEyeOutputViewport", (void *)4);
    check_ptr_parameter("IVRSystem_006_GetEyeOutputViewport", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetProjectionMatrix, 5, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_006_GetProjectionMatrix)(HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
    check_ptr_parameter("IVRSystem_006_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_006_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_006_GetProjectionMatrix", 3.0f);
    check_uint32_parameter("IVRSystem_006_GetProjectionMatrix", 4);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_006_GetProjectionRaw)(Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_006_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_006_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_006_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_006_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_006_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_006_ComputeDistortion, 4, TRUE, TRUE);
    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_006_ComputeDistortion)(DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_006_ComputeDistortion", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_ComputeDistortion", data_ptr_value);
    check_uint32_parameter("IVRSystem_006_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_006_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_006_ComputeDistortion", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_006_GetEyeToHeadTransform)(HmdMatrix34_t *_r, Hmd_Eye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_006_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_006_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_006_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_006_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_006_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_006_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetDXGIOutputInfo, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_006_GetDXGIOutputInfo)(int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetDXGIOutputInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_006_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_GetDXGIOutputInfo", (void *)1);
    check_ptr_parameter("IVRSystem_006_GetDXGIOutputInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_006_AttachToWindow, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_006_AttachToWindow)(void * hWnd) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_AttachToWindow((void *)1);
    check_ptr_parameter("IVRSystem_006_AttachToWindow", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_AttachToWindow", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_006_GetDeviceToAbsoluteTrackingPose)(TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_006_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_006_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_006_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_006_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_006_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_006_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_006_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass)(TrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_006_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
    EDeviceActivityLevel (__stdcall *capi_IVRSystem_006_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetTrackedDeviceActivityLevel(1);
    check_ptr_parameter("IVRSystem_006_GetTrackedDeviceActivityLevel", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetTrackedDeviceActivityLevel", 1);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetTrackedDeviceClass, 1, FALSE, FALSE);
    TrackedDeviceClass (__stdcall *capi_IVRSystem_006_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_006_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_006_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_006_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_006_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_006_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_006_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_006_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_006_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_006_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_006_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_006_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_006_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_006_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_006_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_006_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_006_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_006_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_006_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_006_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_006_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_006_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_006_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_006_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_006_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_006_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_006_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_006_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_006_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_006_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_006_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_006_GetPropErrorNameFromEnum)(TrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_006_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_006_PollNextEvent, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_006_PollNextEvent)(VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_PollNextEvent((void *)1);
    check_ptr_parameter("IVRSystem_006_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_PollNextEvent", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_006_PollNextEventWithPose, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_006_PollNextEventWithPose)(TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_PollNextEventWithPose(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_006_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_006_PollNextEventWithPose", (void *)2);
    check_ptr_parameter("IVRSystem_006_PollNextEventWithPose", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_006_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_006_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetHiddenAreaMesh, 2, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_006_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, Hmd_Eye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetHiddenAreaMesh(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_006_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_006_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetHiddenAreaMesh", 1);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetControllerState, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_006_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetControllerState(1, (void *)2);
    check_ptr_parameter("IVRSystem_006_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_006_GetControllerState", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetControllerStateWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_006_GetControllerStateWithPose)(TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSystem_006_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_006_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_006_GetControllerStateWithPose", (void *)3);
    check_ptr_parameter("IVRSystem_006_GetControllerStateWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_006_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_006_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_006_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_006_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_006_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_006_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_006_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_006_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_006_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_006_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_006_CaptureInputFocus, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_006_CaptureInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_CaptureInputFocus();
    check_ptr_parameter("IVRSystem_006_CaptureInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_006_ReleaseInputFocus, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_006_ReleaseInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_ReleaseInputFocus();
    check_ptr_parameter("IVRSystem_006_ReleaseInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_006_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_006_IsInputFocusCapturedByAnotherProcess)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_IsInputFocusCapturedByAnotherProcess();
    check_ptr_parameter("IVRSystem_006_IsInputFocusCapturedByAnotherProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_006_DriverDebugRequest, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_006_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_DriverDebugRequest(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRSystem_006_DriverDebugRequest", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_DriverDebugRequest", 1);
    check_ptr_parameter("IVRSystem_006_DriverDebugRequest", (void *)2);
    check_ptr_parameter("IVRSystem_006_DriverDebugRequest", (void *)3);
    check_uint32_parameter("IVRSystem_006_DriverDebugRequest", 4);

    init_thunk(t, this_ptr_value, IVRSystem_006_PerformFirmwareUpdate, 1, FALSE, FALSE);
    VRFirmwareError (__stdcall *capi_IVRSystem_006_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_PerformFirmwareUpdate(1);
    check_ptr_parameter("IVRSystem_006_PerformFirmwareUpdate", this_ptr_value);
    check_uint32_parameter("IVRSystem_006_PerformFirmwareUpdate", 1);

    init_thunk(t, this_ptr_value, IVRSystem_006_IsDisplayOnDesktop, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_006_IsDisplayOnDesktop)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_IsDisplayOnDesktop();
    check_ptr_parameter("IVRSystem_006_IsDisplayOnDesktop", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_006_SetDisplayVisibility, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_006_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;

    clear_parameters();
    capi_IVRSystem_006_SetDisplayVisibility(1);
    check_ptr_parameter("IVRSystem_006_SetDisplayVisibility", this_ptr_value);
    check_bool_parameter("IVRSystem_006_SetDisplayVisibility", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRApplications_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRApplications_001_AddApplicationManifest, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_001_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_AddApplicationManifest((void *)1, 1);
    check_ptr_parameter("IVRApplications_001_AddApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_AddApplicationManifest", (void *)1);
    check_bool_parameter("IVRApplications_001_AddApplicationManifest", 1);

    init_thunk(t, this_ptr_value, IVRApplications_001_RemoveApplicationManifest, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_001_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_RemoveApplicationManifest((void *)1);
    check_ptr_parameter("IVRApplications_001_RemoveApplicationManifest", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_RemoveApplicationManifest", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_001_IsApplicationInstalled, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_001_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_IsApplicationInstalled((void *)1);
    check_ptr_parameter("IVRApplications_001_IsApplicationInstalled", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_IsApplicationInstalled", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_001_GetApplicationCount)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_GetApplicationCount();
    check_ptr_parameter("IVRApplications_001_GetApplicationCount", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationKeyByIndex, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_001_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_GetApplicationKeyByIndex(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_001_GetApplicationKeyByIndex", this_ptr_value);
    check_uint32_parameter("IVRApplications_001_GetApplicationKeyByIndex", 1);
    check_ptr_parameter("IVRApplications_001_GetApplicationKeyByIndex", (void *)2);
    check_uint32_parameter("IVRApplications_001_GetApplicationKeyByIndex", 3);

    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_001_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_GetApplicationKeyByProcessId(1, (void *)2, 3);
    check_ptr_parameter("IVRApplications_001_GetApplicationKeyByProcessId", this_ptr_value);
    check_uint32_parameter("IVRApplications_001_GetApplicationKeyByProcessId", 1);
    check_ptr_parameter("IVRApplications_001_GetApplicationKeyByProcessId", (void *)2);
    check_uint32_parameter("IVRApplications_001_GetApplicationKeyByProcessId", 3);

    init_thunk(t, this_ptr_value, IVRApplications_001_LaunchApplication, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_001_LaunchApplication)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_LaunchApplication((void *)1);
    check_ptr_parameter("IVRApplications_001_LaunchApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_LaunchApplication", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_001_LaunchDashboardOverlay, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_001_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_LaunchDashboardOverlay((void *)1);
    check_ptr_parameter("IVRApplications_001_LaunchDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_LaunchDashboardOverlay", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_001_IdentifyApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_001_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_IdentifyApplication(1, (void *)2);
    check_ptr_parameter("IVRApplications_001_IdentifyApplication", this_ptr_value);
    check_uint32_parameter("IVRApplications_001_IdentifyApplication", 1);
    check_ptr_parameter("IVRApplications_001_IdentifyApplication", (void *)2);

    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationProcessId, 1, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_001_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_GetApplicationProcessId((void *)1);
    check_ptr_parameter("IVRApplications_001_GetApplicationProcessId", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_GetApplicationProcessId", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_001_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_GetApplicationsErrorNameFromEnum(1);
    check_ptr_parameter("IVRApplications_001_GetApplicationsErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_001_GetApplicationsErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationPropertyString, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRApplications_001_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyString", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyString", (void *)1);
    check_uint32_parameter("IVRApplications_001_GetApplicationPropertyString", 2);
    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyString", (void *)3);
    check_uint32_parameter("IVRApplications_001_GetApplicationPropertyString", 4);
    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyString", (void *)5);

    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationPropertyBool, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_001_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_GetApplicationPropertyBool((void *)1, 2, (void *)3);
    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyBool", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyBool", (void *)1);
    check_uint32_parameter("IVRApplications_001_GetApplicationPropertyBool", 2);
    check_ptr_parameter("IVRApplications_001_GetApplicationPropertyBool", (void *)3);

    init_thunk(t, this_ptr_value, IVRApplications_001_GetHomeApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_001_GetHomeApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_GetHomeApplication((void *)1, 2);
    check_ptr_parameter("IVRApplications_001_GetHomeApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_GetHomeApplication", (void *)1);
    check_uint32_parameter("IVRApplications_001_GetHomeApplication", 2);

    init_thunk(t, this_ptr_value, IVRApplications_001_SetHomeApplication, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_001_SetHomeApplication)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_SetHomeApplication((void *)1);
    check_ptr_parameter("IVRApplications_001_SetHomeApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_SetHomeApplication", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_001_SetApplicationAutoLaunch, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_001_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_SetApplicationAutoLaunch((void *)1, 1);
    check_ptr_parameter("IVRApplications_001_SetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_SetApplicationAutoLaunch", (void *)1);
    check_bool_parameter("IVRApplications_001_SetApplicationAutoLaunch", 1);

    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationAutoLaunch, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRApplications_001_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_GetApplicationAutoLaunch((void *)1);
    check_ptr_parameter("IVRApplications_001_GetApplicationAutoLaunch", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_GetApplicationAutoLaunch", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_001_GetStartingApplication, 2, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_001_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_GetStartingApplication((void *)1, 2);
    check_ptr_parameter("IVRApplications_001_GetStartingApplication", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_GetStartingApplication", (void *)1);
    check_uint32_parameter("IVRApplications_001_GetStartingApplication", 2);

    init_thunk(t, this_ptr_value, IVRApplications_001_GetTransitionState, 0, FALSE, FALSE);
    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_001_GetTransitionState)() = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_GetTransitionState();
    check_ptr_parameter("IVRApplications_001_GetTransitionState", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRApplications_001_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
    EVRApplicationError (__stdcall *capi_IVRApplications_001_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_PerformApplicationPrelaunchCheck((void *)1);
    check_ptr_parameter("IVRApplications_001_PerformApplicationPrelaunchCheck", this_ptr_value);
    check_ptr_parameter("IVRApplications_001_PerformApplicationPrelaunchCheck", (void *)1);

    init_thunk(t, this_ptr_value, IVRApplications_001_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRApplications_001_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;

    clear_parameters();
    capi_IVRApplications_001_GetApplicationsTransitionStateNameFromEnum(1);
    check_ptr_parameter("IVRApplications_001_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRApplications_001_GetApplicationsTransitionStateNameFromEnum", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRChaperone_002(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRChaperone_002_GetCalibrationState, 0, FALSE, FALSE);
    ChaperoneCalibrationState (__stdcall *capi_IVRChaperone_002_GetCalibrationState)() = (void *)t;

    clear_parameters();
    capi_IVRChaperone_002_GetCalibrationState();
    check_ptr_parameter("IVRChaperone_002_GetCalibrationState", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperone_002_GetSoftBoundsInfo, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperone_002_GetSoftBoundsInfo)(ChaperoneSoftBoundsInfo_t * pInfo) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_002_GetSoftBoundsInfo((void *)1);
    check_ptr_parameter("IVRChaperone_002_GetSoftBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperone_002_GetSoftBoundsInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperone_002_GetHardBoundsInfo, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperone_002_GetHardBoundsInfo)(HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_002_GetHardBoundsInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRChaperone_002_GetHardBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperone_002_GetHardBoundsInfo", (void *)1);
    check_ptr_parameter("IVRChaperone_002_GetHardBoundsInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRChaperone_002_GetSeatedBoundsInfo, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperone_002_GetSeatedBoundsInfo)(ChaperoneSeatedBoundsInfo_t * pInfo) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_002_GetSeatedBoundsInfo((void *)1);
    check_ptr_parameter("IVRChaperone_002_GetSeatedBoundsInfo", this_ptr_value);
    check_ptr_parameter("IVRChaperone_002_GetSeatedBoundsInfo", (void *)1);

    init_thunk(t, this_ptr_value, IVRChaperone_002_ReloadInfo, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperone_002_ReloadInfo)() = (void *)t;

    clear_parameters();
    capi_IVRChaperone_002_ReloadInfo();
    check_ptr_parameter("IVRChaperone_002_ReloadInfo", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperone_002_SetSceneColor, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperone_002_SetSceneColor)(HmdColor_t color) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_002_SetSceneColor(DEFAULT_COLOR);
    check_ptr_parameter("IVRChaperone_002_SetSceneColor", this_ptr_value);
    check_HmdColor_parameter("IVRChaperone_002_SetSceneColor", DEFAULT_COLOR);

    init_thunk(t, this_ptr_value, IVRChaperone_002_GetBoundsColor, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperone_002_GetBoundsColor)(HmdColor_t * pOutputColorArray, int nNumOutputColors) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_002_GetBoundsColor((void *)1, 2);
    check_ptr_parameter("IVRChaperone_002_GetBoundsColor", this_ptr_value);
    check_ptr_parameter("IVRChaperone_002_GetBoundsColor", (void *)1);
    check_uint32_parameter("IVRChaperone_002_GetBoundsColor", 2);

    init_thunk(t, this_ptr_value, IVRChaperone_002_AreBoundsVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRChaperone_002_AreBoundsVisible)() = (void *)t;

    clear_parameters();
    capi_IVRChaperone_002_AreBoundsVisible();
    check_ptr_parameter("IVRChaperone_002_AreBoundsVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRChaperone_002_ForceBoundsVisible, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRChaperone_002_ForceBoundsVisible)(bool bForce) = (void *)t;

    clear_parameters();
    capi_IVRChaperone_002_ForceBoundsVisible(1);
    check_ptr_parameter("IVRChaperone_002_ForceBoundsVisible", this_ptr_value);
    check_bool_parameter("IVRChaperone_002_ForceBoundsVisible", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_008(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_008_GetLastError, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_008_GetLastError)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_GetLastError((void *)1, 2);
    check_ptr_parameter("IVRCompositor_008_GetLastError", this_ptr_value);
    check_ptr_parameter("IVRCompositor_008_GetLastError", (void *)1);
    check_uint32_parameter("IVRCompositor_008_GetLastError", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_008_SetVSync, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_SetVSync)(bool bVSync) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_SetVSync(1);
    check_ptr_parameter("IVRCompositor_008_SetVSync", this_ptr_value);
    check_bool_parameter("IVRCompositor_008_SetVSync", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_008_GetVSync, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_008_GetVSync)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_GetVSync();
    check_ptr_parameter("IVRCompositor_008_GetVSync", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_SetGamma, 1, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_SetGamma)(float fGamma) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_SetGamma(1.0f);
    check_ptr_parameter("IVRCompositor_008_SetGamma", this_ptr_value);
    check_float_parameter("IVRCompositor_008_SetGamma", 1.0f);

    init_thunk(t, this_ptr_value, IVRCompositor_008_GetGamma, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_008_GetGamma)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_GetGamma();
    check_ptr_parameter("IVRCompositor_008_GetGamma", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_WaitGetPoses, 4, FALSE, FALSE);
    VRCompositorError (__stdcall *capi_IVRCompositor_008_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_008_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_008_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_008_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_008_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_008_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_008_Submit, 5, FALSE, FALSE);
    VRCompositorError (__stdcall *capi_IVRCompositor_008_Submit)(Hmd_Eye eEye, GraphicsAPIConvention eTextureType, void * pTexture, VRTextureBounds_t * pBounds, VRSubmitFlags_t nSubmitFlags) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_Submit(1, 2, (void *)3, (void *)4, 5);
    check_ptr_parameter("IVRCompositor_008_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_008_Submit", 1);
    check_uint32_parameter("IVRCompositor_008_Submit", 2);
    check_ptr_parameter("IVRCompositor_008_Submit", (void *)3);
    check_ptr_parameter("IVRCompositor_008_Submit", (void *)4);
    check_uint32_parameter("IVRCompositor_008_Submit", 5);

    init_thunk(t, this_ptr_value, IVRCompositor_008_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_008_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_008_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_008_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_008_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_008_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_008_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_008_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_008_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_008_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_008_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_008_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_008_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_008_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_008_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_008_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_008_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_008_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_008_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_008_SetSkyboxOverride, 7, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_SetSkyboxOverride)(GraphicsAPIConvention eTextureType, void * pFront, void * pBack, void * pLeft, void * pRight, void * pTop, void * pBottom) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_SetSkyboxOverride(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7);
    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", this_ptr_value);
    check_uint32_parameter("IVRCompositor_008_SetSkyboxOverride", 1);
    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", (void *)2);
    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", (void *)3);
    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", (void *)4);
    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", (void *)5);
    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", (void *)6);
    check_ptr_parameter("IVRCompositor_008_SetSkyboxOverride", (void *)7);

    init_thunk(t, this_ptr_value, IVRCompositor_008_ClearSkyboxOverride, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_ClearSkyboxOverride)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_ClearSkyboxOverride();
    check_ptr_parameter("IVRCompositor_008_ClearSkyboxOverride", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_008_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_008_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_CompositorQuit();
    check_ptr_parameter("IVRCompositor_008_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_008_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_IsFullscreen();
    check_ptr_parameter("IVRCompositor_008_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_SetTrackingSpace)(TrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_008_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_008_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_008_GetTrackingSpace, 0, FALSE, FALSE);
    TrackingUniverseOrigin (__stdcall *capi_IVRCompositor_008_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_008_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_008_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_008_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_008_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_CanRenderScene();
    check_ptr_parameter("IVRCompositor_008_CanRenderScene", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_ShowMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_ShowMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_ShowMirrorWindow();
    check_ptr_parameter("IVRCompositor_008_ShowMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_HideMirrorWindow, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_HideMirrorWindow)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_HideMirrorWindow();
    check_ptr_parameter("IVRCompositor_008_HideMirrorWindow", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_CompositorDumpImages, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_008_CompositorDumpImages)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_CompositorDumpImages();
    check_ptr_parameter("IVRCompositor_008_CompositorDumpImages", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_GetFrameTimeRemaining, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_008_GetFrameTimeRemaining)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_GetFrameTimeRemaining();
    check_ptr_parameter("IVRCompositor_008_GetFrameTimeRemaining", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_008_GetLastFrameRenderer, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_008_GetLastFrameRenderer)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_008_GetLastFrameRenderer();
    check_ptr_parameter("IVRCompositor_008_GetLastFrameRenderer", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRNotifications_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRNotifications_001_GetErrorString, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRNotifications_001_GetErrorString)(NotificationError_t error, char * pchBuffer, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRNotifications_001_GetErrorString(1, (void *)2, 3);
    check_ptr_parameter("IVRNotifications_001_GetErrorString", this_ptr_value);
    check_uint32_parameter("IVRNotifications_001_GetErrorString", 1);
    check_ptr_parameter("IVRNotifications_001_GetErrorString", (void *)2);
    check_uint32_parameter("IVRNotifications_001_GetErrorString", 3);

    init_thunk(t, this_ptr_value, IVRNotifications_001_CreateNotification, 7, FALSE, FALSE);
    NotificationError_t (__stdcall *capi_IVRNotifications_001_CreateNotification)(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, const char * strType, const char * strText, const char * strCategory, NotificationBitmap * photo, VRNotificationId * notificationId) = (void *)t;

    clear_parameters();
    capi_IVRNotifications_001_CreateNotification(1, 2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7);
    check_ptr_parameter("IVRNotifications_001_CreateNotification", this_ptr_value);
    check_uint64_parameter("IVRNotifications_001_CreateNotification", 1);
    check_uint64_parameter("IVRNotifications_001_CreateNotification", 2);
    check_ptr_parameter("IVRNotifications_001_CreateNotification", (void *)3);
    check_ptr_parameter("IVRNotifications_001_CreateNotification", (void *)4);
    check_ptr_parameter("IVRNotifications_001_CreateNotification", (void *)5);
    check_ptr_parameter("IVRNotifications_001_CreateNotification", (void *)6);
    check_ptr_parameter("IVRNotifications_001_CreateNotification", (void *)7);

    init_thunk(t, this_ptr_value, IVRNotifications_001_DismissNotification, 1, FALSE, FALSE);
    NotificationError_t (__stdcall *capi_IVRNotifications_001_DismissNotification)(VRNotificationId notificationId) = (void *)t;

    clear_parameters();
    capi_IVRNotifications_001_DismissNotification(1);
    check_ptr_parameter("IVRNotifications_001_DismissNotification", this_ptr_value);
    check_uint32_parameter("IVRNotifications_001_DismissNotification", 1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_005(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_005_FindOverlay, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_005_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_005_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_005_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_CreateOverlay, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_005_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_005_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_005_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_005_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_005_DestroyOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_005_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetHighQualityOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_005_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_005_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_005_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_005_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_005_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_005_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_005_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_005_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_005_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_005_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_005_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayImageData, 5, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_005_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_005_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_005_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_005_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_005_GetOverlayErrorNameFromEnum)(VROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_005_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_005_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayFlag, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_005_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_005_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_005_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayFlag, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_005_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_005_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_005_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayColor, 4, TRUE, TRUE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_005_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_005_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_005_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_005_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayColor, 4, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_005_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_005_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_005_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayAlpha, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_005_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_005_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayAlpha, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_005_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayGamma, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float fGamma) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayGamma(1, 2.0f);
    check_ptr_parameter("IVROverlay_005_SetOverlayGamma", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayGamma", 1);
    check_float_parameter("IVROverlay_005_SetOverlayGamma", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayGamma, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float * pfGamma) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayGamma(1, (void *)2);
    check_ptr_parameter("IVROverlay_005_GetOverlayGamma", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayGamma", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayGamma", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_005_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_005_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_005_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_005_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_005_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayTextureBounds, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_005_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_005_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayTextureBounds, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_005_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayTransformType, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_005_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_005_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_005_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_005_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_005_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_005_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_005_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_005_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_005_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_005_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_005_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_005_ShowOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_005_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_005_HideOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_HideOverlay(1);
    check_ptr_parameter("IVROverlay_005_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_005_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_005_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_005_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_005_PollNextOverlayEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_005_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_PollNextOverlayEvent(1, (void *)2);
    check_ptr_parameter("IVROverlay_005_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_005_PollNextOverlayEvent", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayInputMethod, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_005_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayInputMethod, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_005_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_005_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetOverlayMouseScale, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_005_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_005_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayMouseScale, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_005_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_005_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_005_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_005_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_005_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_005_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_005_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_005_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_005_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_005_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_005_IsFocusOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_005_IsFocusOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_IsFocusOverlay(1);
    check_ptr_parameter("IVROverlay_005_IsFocusOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_IsFocusOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayTexture, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayTexture(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_005_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayTexture", 1);
    check_uint32_parameter("IVROverlay_005_SetOverlayTexture", 2);
    check_ptr_parameter("IVROverlay_005_SetOverlayTexture", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_005_ClearOverlayTexture, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_005_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayRaw, 5, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_005_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_005_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_005_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_005_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_005_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetOverlayFromFile, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_005_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_005_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_CreateDashboardOverlay, 4, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_005_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_005_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_005_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_005_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_005_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_005_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_005_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_005_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_005_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_005_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_005_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_005_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_005_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_005_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_005_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_005_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_005_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_005_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_005_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_005_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_005_ShowDashboard", (void *)1);

    init_thunk(t, this_ptr_value, IVROverlay_005_ShowKeyboard, 6, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_005_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1);
    check_ptr_parameter("IVROverlay_005_ShowKeyboard", this_ptr_value);
    check_uint32_parameter("IVROverlay_005_ShowKeyboard", 1);
    check_uint32_parameter("IVROverlay_005_ShowKeyboard", 2);
    check_ptr_parameter("IVROverlay_005_ShowKeyboard", (void *)3);
    check_uint32_parameter("IVROverlay_005_ShowKeyboard", 4);
    check_ptr_parameter("IVROverlay_005_ShowKeyboard", (void *)5);
    check_bool_parameter("IVROverlay_005_ShowKeyboard", 1);

    init_thunk(t, this_ptr_value, IVROverlay_005_GetKeyboardText, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_005_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_GetKeyboardText((void *)1, 2);
    check_ptr_parameter("IVROverlay_005_GetKeyboardText", this_ptr_value);
    check_ptr_parameter("IVROverlay_005_GetKeyboardText", (void *)1);
    check_uint32_parameter("IVROverlay_005_GetKeyboardText", 2);

    init_thunk(t, this_ptr_value, IVROverlay_005_HideKeyboard, 0, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_005_HideKeyboard)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_005_HideKeyboard();
    check_ptr_parameter("IVROverlay_005_HideKeyboard", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRRenderModels_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRRenderModels_001_LoadRenderModel, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRRenderModels_001_LoadRenderModel)(const char * pchRenderModelName, RenderModel_t * pRenderModel) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_001_LoadRenderModel((void *)1, (void *)2);
    check_ptr_parameter("IVRRenderModels_001_LoadRenderModel", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_001_LoadRenderModel", (void *)1);
    check_ptr_parameter("IVRRenderModels_001_LoadRenderModel", (void *)2);

    init_thunk(t, this_ptr_value, IVRRenderModels_001_FreeRenderModel, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRRenderModels_001_FreeRenderModel)(RenderModel_t * pRenderModel) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_001_FreeRenderModel((void *)1);
    check_ptr_parameter("IVRRenderModels_001_FreeRenderModel", this_ptr_value);
    check_ptr_parameter("IVRRenderModels_001_FreeRenderModel", (void *)1);

    init_thunk(t, this_ptr_value, IVRRenderModels_001_GetRenderModelName, 3, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_001_GetRenderModelName)(uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen) = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_001_GetRenderModelName(1, (void *)2, 3);
    check_ptr_parameter("IVRRenderModels_001_GetRenderModelName", this_ptr_value);
    check_uint32_parameter("IVRRenderModels_001_GetRenderModelName", 1);
    check_ptr_parameter("IVRRenderModels_001_GetRenderModelName", (void *)2);
    check_uint32_parameter("IVRRenderModels_001_GetRenderModelName", 3);

    init_thunk(t, this_ptr_value, IVRRenderModels_001_GetRenderModelCount, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRRenderModels_001_GetRenderModelCount)() = (void *)t;

    clear_parameters();
    capi_IVRRenderModels_001_GetRenderModelCount();
    check_ptr_parameter("IVRRenderModels_001_GetRenderModelCount", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_005(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetWindowBounds, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_005_GetWindowBounds)(int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetWindowBounds((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSystem_005_GetWindowBounds", this_ptr_value);
    check_ptr_parameter("IVRSystem_005_GetWindowBounds", (void *)1);
    check_ptr_parameter("IVRSystem_005_GetWindowBounds", (void *)2);
    check_ptr_parameter("IVRSystem_005_GetWindowBounds", (void *)3);
    check_ptr_parameter("IVRSystem_005_GetWindowBounds", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_005_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_005_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_005_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_005_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetEyeOutputViewport, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_005_GetEyeOutputViewport)(Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetEyeOutputViewport(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_005_GetEyeOutputViewport", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetEyeOutputViewport", 1);
    check_ptr_parameter("IVRSystem_005_GetEyeOutputViewport", (void *)2);
    check_ptr_parameter("IVRSystem_005_GetEyeOutputViewport", (void *)3);
    check_ptr_parameter("IVRSystem_005_GetEyeOutputViewport", (void *)4);
    check_ptr_parameter("IVRSystem_005_GetEyeOutputViewport", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetProjectionMatrix, 5, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_005_GetProjectionMatrix)(HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
    check_ptr_parameter("IVRSystem_005_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_005_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_005_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_005_GetProjectionMatrix", 3.0f);
    check_uint32_parameter("IVRSystem_005_GetProjectionMatrix", 4);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_005_GetProjectionRaw)(Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_005_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_005_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_005_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_005_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_005_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_005_ComputeDistortion, 4, TRUE, TRUE);
    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_005_ComputeDistortion)(DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_005_ComputeDistortion", this_ptr_value);
    check_ptr_parameter("IVRSystem_005_ComputeDistortion", data_ptr_value);
    check_uint32_parameter("IVRSystem_005_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_005_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_005_ComputeDistortion", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_005_GetEyeToHeadTransform)(HmdMatrix34_t *_r, Hmd_Eye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_005_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_005_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_005_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_005_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_005_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_005_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_005_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_005_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetDXGIOutputInfo, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_005_GetDXGIOutputInfo)(int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetDXGIOutputInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_005_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_005_GetDXGIOutputInfo", (void *)1);
    check_ptr_parameter("IVRSystem_005_GetDXGIOutputInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_005_AttachToWindow, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_005_AttachToWindow)(void * hWnd) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_AttachToWindow((void *)1);
    check_ptr_parameter("IVRSystem_005_AttachToWindow", this_ptr_value);
    check_ptr_parameter("IVRSystem_005_AttachToWindow", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_005_GetDeviceToAbsoluteTrackingPose)(TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_005_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_005_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_005_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_005_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_005_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_005_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_005_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_005_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass)(TrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
    check_ptr_parameter("IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass", 1);
    check_ptr_parameter("IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
    check_uint32_parameter("IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass", 3);
    check_uint32_parameter("IVRSystem_005_GetSortedTrackedDeviceIndicesOfClass", 4);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetTrackedDeviceClass, 1, FALSE, FALSE);
    TrackedDeviceClass (__stdcall *capi_IVRSystem_005_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_005_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_005_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_005_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_005_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_005_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_005_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_005_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_005_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_005_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_005_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_005_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_005_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_005_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_005_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_005_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_005_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_005_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_005_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_005_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_005_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_005_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_005_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_005_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_005_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_005_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_005_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_005_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_005_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_005_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_005_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_005_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_005_GetPropErrorNameFromEnum)(TrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_005_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_005_PollNextEvent, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_005_PollNextEvent)(VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_PollNextEvent((void *)1);
    check_ptr_parameter("IVRSystem_005_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_005_PollNextEvent", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_005_PollNextEventWithPose, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_005_PollNextEventWithPose)(TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_PollNextEventWithPose(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_005_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_005_PollNextEventWithPose", (void *)2);
    check_ptr_parameter("IVRSystem_005_PollNextEventWithPose", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_005_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_005_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetHiddenAreaMesh, 2, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_005_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, Hmd_Eye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetHiddenAreaMesh(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_005_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_005_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetHiddenAreaMesh", 1);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetControllerState, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_005_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetControllerState(1, (void *)2);
    check_ptr_parameter("IVRSystem_005_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_005_GetControllerState", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetControllerStateWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_005_GetControllerStateWithPose)(TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSystem_005_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_005_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_005_GetControllerStateWithPose", (void *)3);
    check_ptr_parameter("IVRSystem_005_GetControllerStateWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_005_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_005_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_005_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_005_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_005_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_005_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_005_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_005_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_005_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_005_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_005_CaptureInputFocus, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_005_CaptureInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_CaptureInputFocus();
    check_ptr_parameter("IVRSystem_005_CaptureInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_005_ReleaseInputFocus, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_005_ReleaseInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_ReleaseInputFocus();
    check_ptr_parameter("IVRSystem_005_ReleaseInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_005_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_005_IsInputFocusCapturedByAnotherProcess)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_IsInputFocusCapturedByAnotherProcess();
    check_ptr_parameter("IVRSystem_005_IsInputFocusCapturedByAnotherProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_005_DriverDebugRequest, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_005_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_005_DriverDebugRequest(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRSystem_005_DriverDebugRequest", this_ptr_value);
    check_uint32_parameter("IVRSystem_005_DriverDebugRequest", 1);
    check_ptr_parameter("IVRSystem_005_DriverDebugRequest", (void *)2);
    check_ptr_parameter("IVRSystem_005_DriverDebugRequest", (void *)3);
    check_uint32_parameter("IVRSystem_005_DriverDebugRequest", 4);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_007(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_007_GetLastError, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_007_GetLastError)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_GetLastError((void *)1, 2);
    check_ptr_parameter("IVRCompositor_007_GetLastError", this_ptr_value);
    check_ptr_parameter("IVRCompositor_007_GetLastError", (void *)1);
    check_uint32_parameter("IVRCompositor_007_GetLastError", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_007_SetVSync, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_007_SetVSync)(bool bVSync) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_SetVSync(1);
    check_ptr_parameter("IVRCompositor_007_SetVSync", this_ptr_value);
    check_bool_parameter("IVRCompositor_007_SetVSync", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_007_GetVSync, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_007_GetVSync)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_GetVSync();
    check_ptr_parameter("IVRCompositor_007_GetVSync", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_007_SetGamma, 1, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_007_SetGamma)(float fGamma) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_SetGamma(1.0f);
    check_ptr_parameter("IVRCompositor_007_SetGamma", this_ptr_value);
    check_float_parameter("IVRCompositor_007_SetGamma", 1.0f);

    init_thunk(t, this_ptr_value, IVRCompositor_007_GetGamma, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_007_GetGamma)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_GetGamma();
    check_ptr_parameter("IVRCompositor_007_GetGamma", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_007_WaitGetPoses, 4, FALSE, FALSE);
    VRCompositorError (__stdcall *capi_IVRCompositor_007_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_007_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_007_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_007_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_007_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_007_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_007_Submit, 4, FALSE, FALSE);
    VRCompositorError (__stdcall *capi_IVRCompositor_007_Submit)(Hmd_Eye eEye, GraphicsAPIConvention eTextureType, void * pTexture, VRTextureBounds_t * pBounds) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_Submit(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRCompositor_007_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_007_Submit", 1);
    check_uint32_parameter("IVRCompositor_007_Submit", 2);
    check_ptr_parameter("IVRCompositor_007_Submit", (void *)3);
    check_ptr_parameter("IVRCompositor_007_Submit", (void *)4);

    init_thunk(t, this_ptr_value, IVRCompositor_007_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_007_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_007_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_007_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_007_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_007_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_007_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_007_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_007_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_007_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_007_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_007_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_007_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_007_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_007_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_007_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_007_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_007_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_007_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_007_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_007_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_007_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_007_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_007_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_007_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_007_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_007_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_007_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_007_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_007_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_CompositorQuit();
    check_ptr_parameter("IVRCompositor_007_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_007_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_007_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_IsFullscreen();
    check_ptr_parameter("IVRCompositor_007_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_007_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_007_SetTrackingSpace)(TrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_007_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_007_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_007_GetTrackingSpace, 0, FALSE, FALSE);
    TrackingUniverseOrigin (__stdcall *capi_IVRCompositor_007_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_007_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_007_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_007_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_007_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_007_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_007_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_007_CanRenderScene();
    check_ptr_parameter("IVRCompositor_007_CanRenderScene", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_004(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_004_FindOverlay, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_004_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_004_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_004_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_CreateOverlay, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_004_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_004_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_004_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_004_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_004_DestroyOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_004_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetHighQualityOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_004_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_004_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_004_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_004_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_004_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_004_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_004_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_004_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_004_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_004_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_004_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayImageData, 5, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_004_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_004_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_004_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_004_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_004_GetOverlayErrorNameFromEnum)(VROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_004_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_004_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayFlag, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_004_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_004_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_004_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayFlag, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_004_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_004_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_004_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayColor, 4, TRUE, TRUE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_004_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_004_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_004_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_004_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayColor, 4, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_004_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_004_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_004_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayAlpha, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_004_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_004_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayAlpha, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_004_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayGamma, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float fGamma) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayGamma(1, 2.0f);
    check_ptr_parameter("IVROverlay_004_SetOverlayGamma", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayGamma", 1);
    check_float_parameter("IVROverlay_004_SetOverlayGamma", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayGamma, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float * pfGamma) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayGamma(1, (void *)2);
    check_ptr_parameter("IVROverlay_004_GetOverlayGamma", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayGamma", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayGamma", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_004_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_004_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_004_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
    check_ptr_parameter("IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_float_parameter("IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
    check_float_parameter("IVROverlay_004_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
    check_ptr_parameter("IVROverlay_004_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayTextureBounds, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_004_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_004_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayTextureBounds, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_004_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayTransformType, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_004_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_004_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_004_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_004_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_004_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_004_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_004_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_004_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_004_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_004_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_004_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_004_ShowOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_004_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_004_HideOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_HideOverlay(1);
    check_ptr_parameter("IVROverlay_004_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_004_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_004_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_004_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_004_PollNextOverlayEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_004_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_PollNextOverlayEvent(1, (void *)2);
    check_ptr_parameter("IVROverlay_004_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_004_PollNextOverlayEvent", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayInputMethod, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_004_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayInputMethod, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_004_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_004_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetOverlayMouseScale, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_004_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_004_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayMouseScale, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_004_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_004_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_004_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_004_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_004_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_004_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_004_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_004_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_004_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_004_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayTexture, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayTexture(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_004_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayTexture", 1);
    check_uint32_parameter("IVROverlay_004_SetOverlayTexture", 2);
    check_ptr_parameter("IVROverlay_004_SetOverlayTexture", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_004_ClearOverlayTexture, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_004_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayRaw, 5, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_004_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_004_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_004_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_004_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_004_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetOverlayFromFile, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_004_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_004_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_CreateDashboardOverlay, 4, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_004_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_004_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_004_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_004_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_004_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_004_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_004_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_004_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_004_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_004_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_004_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_004_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_004_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_004_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_004_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_004_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_004_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_004_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_004_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_004_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_004_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_004_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_004_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_004_ShowDashboard", (void *)1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_003(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_003_FindOverlay, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_003_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_003_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_003_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_CreateOverlay, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_003_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_003_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_003_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_003_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_003_DestroyOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_003_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetHighQualityOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_003_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_003_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_003_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayKey, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_003_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayKey(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_003_GetOverlayKey", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayKey", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayKey", (void *)2);
    check_uint32_parameter("IVROverlay_003_GetOverlayKey", 3);
    check_ptr_parameter("IVROverlay_003_GetOverlayKey", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayName, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVROverlay_003_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, VROverlayError * pError) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayName(1, (void *)2, 3, (void *)4);
    check_ptr_parameter("IVROverlay_003_GetOverlayName", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayName", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayName", (void *)2);
    check_uint32_parameter("IVROverlay_003_GetOverlayName", 3);
    check_ptr_parameter("IVROverlay_003_GetOverlayName", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayImageData, 5, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
    check_ptr_parameter("IVROverlay_003_GetOverlayImageData", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayImageData", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayImageData", (void *)2);
    check_uint32_parameter("IVROverlay_003_GetOverlayImageData", 3);
    check_ptr_parameter("IVROverlay_003_GetOverlayImageData", (void *)4);
    check_ptr_parameter("IVROverlay_003_GetOverlayImageData", (void *)5);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_003_GetOverlayErrorNameFromEnum)(VROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_003_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_003_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayFlag, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_003_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_003_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_003_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayFlag, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_003_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_003_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_003_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayColor, 4, TRUE, TRUE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_003_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_003_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_003_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_003_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayColor, 4, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_003_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_003_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_003_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayAlpha, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_003_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_003_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayAlpha, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_003_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayGamma, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float fGamma) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayGamma(1, 2.0f);
    check_ptr_parameter("IVROverlay_003_SetOverlayGamma", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayGamma", 1);
    check_float_parameter("IVROverlay_003_SetOverlayGamma", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayGamma, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float * pfGamma) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayGamma(1, (void *)2);
    check_ptr_parameter("IVROverlay_003_GetOverlayGamma", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayGamma", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayGamma", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_003_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_003_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_003_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayTextureBounds, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_003_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_003_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayTextureBounds, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_003_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayTransformType, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_003_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_003_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_003_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_003_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_003_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_003_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_003_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_003_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_003_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_003_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_003_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_003_ShowOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_003_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_003_HideOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_HideOverlay(1);
    check_ptr_parameter("IVROverlay_003_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_003_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_003_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_003_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_003_PollNextOverlayEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_003_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_PollNextOverlayEvent(1, (void *)2);
    check_ptr_parameter("IVROverlay_003_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_003_PollNextOverlayEvent", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayInputMethod, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_003_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayInputMethod, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_003_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_003_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetOverlayMouseScale, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_003_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_003_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayMouseScale, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_003_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_003_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_003_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_003_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_003_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_003_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_003_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_003_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_003_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_003_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayTexture, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayTexture(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_003_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayTexture", 1);
    check_uint32_parameter("IVROverlay_003_SetOverlayTexture", 2);
    check_ptr_parameter("IVROverlay_003_SetOverlayTexture", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_003_ClearOverlayTexture, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_003_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayRaw, 5, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_003_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_003_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_003_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_003_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_003_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetOverlayFromFile, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_003_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_003_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_CreateDashboardOverlay, 4, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_003_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_003_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_003_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_003_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_003_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_003_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_003_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_003_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_003_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_003_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_003_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_003_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_003_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_003_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_003_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_003_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_003_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_003_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_003_GetDashboardOverlaySceneProcess", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_003_ShowDashboard, 1, FALSE, FALSE);
    void (__stdcall *capi_IVROverlay_003_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;

    clear_parameters();
    capi_IVROverlay_003_ShowDashboard((void *)1);
    check_ptr_parameter("IVROverlay_003_ShowDashboard", this_ptr_value);
    check_ptr_parameter("IVROverlay_003_ShowDashboard", (void *)1);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_002(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_002_FindOverlay, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_002_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_002_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_002_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_002_CreateOverlay, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_002_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_002_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_002_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_002_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_002_DestroyOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_002_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetHighQualityOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_002_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_002_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_002_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_002_GetOverlayErrorNameFromEnum)(VROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_002_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_002_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayFlag, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_002_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_002_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_002_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayFlag, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_002_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_002_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_002_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayColor, 4, TRUE, TRUE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
    check_ptr_parameter("IVROverlay_002_SetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayColor", 1);
    check_float_parameter("IVROverlay_002_SetOverlayColor", 2.0f);
    check_float_parameter("IVROverlay_002_SetOverlayColor", 3.0f);
    check_float_parameter("IVROverlay_002_SetOverlayColor", 4.0f);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayColor, 4, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_002_GetOverlayColor", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_GetOverlayColor", 1);
    check_ptr_parameter("IVROverlay_002_GetOverlayColor", (void *)2);
    check_ptr_parameter("IVROverlay_002_GetOverlayColor", (void *)3);
    check_ptr_parameter("IVROverlay_002_GetOverlayColor", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayAlpha, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_002_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_002_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayAlpha, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_002_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_002_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayGamma, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float fGamma) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayGamma(1, 2.0f);
    check_ptr_parameter("IVROverlay_002_SetOverlayGamma", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayGamma", 1);
    check_float_parameter("IVROverlay_002_SetOverlayGamma", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayGamma, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float * pfGamma) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetOverlayGamma(1, (void *)2);
    check_ptr_parameter("IVROverlay_002_GetOverlayGamma", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_GetOverlayGamma", 1);
    check_ptr_parameter("IVROverlay_002_GetOverlayGamma", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_002_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_002_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_002_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_002_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayTextureBounds, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_002_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_002_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayTextureBounds, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_002_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_002_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayTransformType, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_002_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_002_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_002_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_002_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_002_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_002_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_002_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_002_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_002_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_002_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_002_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_002_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_002_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_002_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_002_ShowOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_002_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_002_HideOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_HideOverlay(1);
    check_ptr_parameter("IVROverlay_002_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_002_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_002_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_002_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_002_PollNextOverlayEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_002_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_PollNextOverlayEvent(1, (void *)2);
    check_ptr_parameter("IVROverlay_002_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_002_PollNextOverlayEvent", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayInputMethod, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_002_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_002_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayInputMethod, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_002_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_002_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetOverlayMouseScale, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_002_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_002_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayMouseScale, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_002_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_002_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_002_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_002_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_002_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_002_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_002_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_002_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_002_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_002_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_002_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayTexture, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, GraphicsAPIConvention eTextureType, void * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayTexture(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_002_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayTexture", 1);
    check_uint32_parameter("IVROverlay_002_SetOverlayTexture", 2);
    check_ptr_parameter("IVROverlay_002_SetOverlayTexture", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_002_ClearOverlayTexture, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_ClearOverlayTexture(1);
    check_ptr_parameter("IVROverlay_002_ClearOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_ClearOverlayTexture", 1);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayRaw, 5, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_002_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_002_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_002_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_002_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_002_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetOverlayFromFile, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_002_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_002_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_002_CreateDashboardOverlay, 4, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVROverlay_002_CreateDashboardOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_002_CreateDashboardOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_002_CreateDashboardOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_002_CreateDashboardOverlay", (void *)3);
    check_ptr_parameter("IVROverlay_002_CreateDashboardOverlay", (void *)4);

    init_thunk(t, this_ptr_value, IVROverlay_002_IsDashboardVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_002_IsDashboardVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_IsDashboardVisible();
    check_ptr_parameter("IVROverlay_002_IsDashboardVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_002_IsActiveDashboardOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_002_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_IsActiveDashboardOverlay(1);
    check_ptr_parameter("IVROverlay_002_IsActiveDashboardOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_IsActiveDashboardOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_002_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_SetDashboardOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_002_SetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_SetDashboardOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_002_SetDashboardOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_002_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_002_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_002_GetDashboardOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_002_GetDashboardOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_002_GetDashboardOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_002_GetDashboardOverlaySceneProcess", (void *)2);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_004(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetWindowBounds, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_004_GetWindowBounds)(int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetWindowBounds((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSystem_004_GetWindowBounds", this_ptr_value);
    check_ptr_parameter("IVRSystem_004_GetWindowBounds", (void *)1);
    check_ptr_parameter("IVRSystem_004_GetWindowBounds", (void *)2);
    check_ptr_parameter("IVRSystem_004_GetWindowBounds", (void *)3);
    check_ptr_parameter("IVRSystem_004_GetWindowBounds", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_004_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_004_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_004_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_004_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetEyeOutputViewport, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_004_GetEyeOutputViewport)(Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetEyeOutputViewport(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_004_GetEyeOutputViewport", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetEyeOutputViewport", 1);
    check_ptr_parameter("IVRSystem_004_GetEyeOutputViewport", (void *)2);
    check_ptr_parameter("IVRSystem_004_GetEyeOutputViewport", (void *)3);
    check_ptr_parameter("IVRSystem_004_GetEyeOutputViewport", (void *)4);
    check_ptr_parameter("IVRSystem_004_GetEyeOutputViewport", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetProjectionMatrix, 5, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_004_GetProjectionMatrix)(HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
    check_ptr_parameter("IVRSystem_004_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_004_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_004_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_004_GetProjectionMatrix", 3.0f);
    check_uint32_parameter("IVRSystem_004_GetProjectionMatrix", 4);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_004_GetProjectionRaw)(Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_004_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_004_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_004_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_004_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_004_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_004_ComputeDistortion, 4, TRUE, TRUE);
    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_004_ComputeDistortion)(DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_004_ComputeDistortion", this_ptr_value);
    check_ptr_parameter("IVRSystem_004_ComputeDistortion", data_ptr_value);
    check_uint32_parameter("IVRSystem_004_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_004_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_004_ComputeDistortion", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_004_GetEyeToHeadTransform)(HmdMatrix34_t *_r, Hmd_Eye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_004_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_004_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_004_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_004_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_004_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_004_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_004_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_004_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetDXGIOutputInfo, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_004_GetDXGIOutputInfo)(int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetDXGIOutputInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_004_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_004_GetDXGIOutputInfo", (void *)1);
    check_ptr_parameter("IVRSystem_004_GetDXGIOutputInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_004_AttachToWindow, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_004_AttachToWindow)(void * hWnd) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_AttachToWindow((void *)1);
    check_ptr_parameter("IVRSystem_004_AttachToWindow", this_ptr_value);
    check_ptr_parameter("IVRSystem_004_AttachToWindow", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_004_GetDeviceToAbsoluteTrackingPose)(TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_004_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_004_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_004_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_004_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_004_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_004_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_004_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_004_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetTrackedDeviceClass, 1, FALSE, FALSE);
    TrackedDeviceClass (__stdcall *capi_IVRSystem_004_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_004_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_004_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_004_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_004_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_004_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_004_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_004_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_004_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_004_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_004_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_004_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_004_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_004_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_004_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_004_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_004_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_004_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_004_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_004_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_004_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_004_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_004_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_004_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_004_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_004_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_004_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_004_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_004_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_004_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_004_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_004_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_004_GetPropErrorNameFromEnum)(TrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_004_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_004_PollNextEvent, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_004_PollNextEvent)(VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_PollNextEvent((void *)1);
    check_ptr_parameter("IVRSystem_004_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_004_PollNextEvent", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_004_PollNextEventWithPose, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_004_PollNextEventWithPose)(TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_PollNextEventWithPose(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_004_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_004_PollNextEventWithPose", (void *)2);
    check_ptr_parameter("IVRSystem_004_PollNextEventWithPose", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_004_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_004_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetHiddenAreaMesh, 2, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_004_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, Hmd_Eye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetHiddenAreaMesh(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_004_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_004_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetHiddenAreaMesh", 1);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetControllerState, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_004_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetControllerState(1, (void *)2);
    check_ptr_parameter("IVRSystem_004_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_004_GetControllerState", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetControllerStateWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_004_GetControllerStateWithPose)(TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSystem_004_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_004_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_004_GetControllerStateWithPose", (void *)3);
    check_ptr_parameter("IVRSystem_004_GetControllerStateWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_004_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_004_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_004_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_004_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_004_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_004_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_004_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_004_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_004_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_004_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_004_CaptureInputFocus, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_004_CaptureInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_CaptureInputFocus();
    check_ptr_parameter("IVRSystem_004_CaptureInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_004_ReleaseInputFocus, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_004_ReleaseInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_ReleaseInputFocus();
    check_ptr_parameter("IVRSystem_004_ReleaseInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_004_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_004_IsInputFocusCapturedByAnotherProcess)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_IsInputFocusCapturedByAnotherProcess();
    check_ptr_parameter("IVRSystem_004_IsInputFocusCapturedByAnotherProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_004_DriverDebugRequest, 4, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_004_DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRSystem_004_DriverDebugRequest(1, (void *)2, (void *)3, 4);
    check_ptr_parameter("IVRSystem_004_DriverDebugRequest", this_ptr_value);
    check_uint32_parameter("IVRSystem_004_DriverDebugRequest", 1);
    check_ptr_parameter("IVRSystem_004_DriverDebugRequest", (void *)2);
    check_ptr_parameter("IVRSystem_004_DriverDebugRequest", (void *)3);
    check_uint32_parameter("IVRSystem_004_DriverDebugRequest", 4);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_006(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_006_GetLastError, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_006_GetLastError)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_GetLastError((void *)1, 2);
    check_ptr_parameter("IVRCompositor_006_GetLastError", this_ptr_value);
    check_ptr_parameter("IVRCompositor_006_GetLastError", (void *)1);
    check_uint32_parameter("IVRCompositor_006_GetLastError", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_006_SetVSync, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_006_SetVSync)(bool bVSync) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_SetVSync(1);
    check_ptr_parameter("IVRCompositor_006_SetVSync", this_ptr_value);
    check_bool_parameter("IVRCompositor_006_SetVSync", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_006_GetVSync, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_006_GetVSync)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_GetVSync();
    check_ptr_parameter("IVRCompositor_006_GetVSync", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_006_SetGamma, 1, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_006_SetGamma)(float fGamma) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_SetGamma(1.0f);
    check_ptr_parameter("IVRCompositor_006_SetGamma", this_ptr_value);
    check_float_parameter("IVRCompositor_006_SetGamma", 1.0f);

    init_thunk(t, this_ptr_value, IVRCompositor_006_GetGamma, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_006_GetGamma)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_GetGamma();
    check_ptr_parameter("IVRCompositor_006_GetGamma", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_006_SetGraphicsDevice, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_006_SetGraphicsDevice)(Compositor_DeviceType eType, void * pDevice) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_SetGraphicsDevice(1, (void *)2);
    check_ptr_parameter("IVRCompositor_006_SetGraphicsDevice", this_ptr_value);
    check_uint32_parameter("IVRCompositor_006_SetGraphicsDevice", 1);
    check_ptr_parameter("IVRCompositor_006_SetGraphicsDevice", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_006_WaitGetPoses, 4, FALSE, FALSE);
    VRCompositorError (__stdcall *capi_IVRCompositor_006_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_WaitGetPoses((void *)1, 2, (void *)3, 4);
    check_ptr_parameter("IVRCompositor_006_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_006_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_006_WaitGetPoses", 2);
    check_ptr_parameter("IVRCompositor_006_WaitGetPoses", (void *)3);
    check_uint32_parameter("IVRCompositor_006_WaitGetPoses", 4);

    init_thunk(t, this_ptr_value, IVRCompositor_006_Submit, 3, FALSE, FALSE);
    VRCompositorError (__stdcall *capi_IVRCompositor_006_Submit)(Hmd_Eye eEye, void * pTexture, VRTextureBounds_t * pBounds) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_Submit(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_006_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_006_Submit", 1);
    check_ptr_parameter("IVRCompositor_006_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_006_Submit", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_006_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_006_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_006_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_006_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_006_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_006_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_006_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_006_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_006_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_006_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_006_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_006_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_006_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_006_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_006_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_006_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_006_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_006_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_006_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_006_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_006_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_006_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_006_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_006_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_006_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_006_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_006_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_006_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_006_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_006_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_CompositorQuit();
    check_ptr_parameter("IVRCompositor_006_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_006_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_006_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_IsFullscreen();
    check_ptr_parameter("IVRCompositor_006_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_006_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_006_SetTrackingSpace)(TrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_006_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_006_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_006_GetTrackingSpace, 0, FALSE, FALSE);
    TrackingUniverseOrigin (__stdcall *capi_IVRCompositor_006_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_006_GetTrackingSpace", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_006_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_006_GetCurrentSceneFocusProcess)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_GetCurrentSceneFocusProcess();
    check_ptr_parameter("IVRCompositor_006_GetCurrentSceneFocusProcess", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_006_CanRenderScene, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_006_CanRenderScene)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_006_CanRenderScene();
    check_ptr_parameter("IVRCompositor_006_CanRenderScene", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVROverlay_001(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVROverlay_001_FindOverlay, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_FindOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVROverlay_001_FindOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_001_FindOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_001_FindOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_CreateOverlay, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_CreateOverlay((void *)1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_001_CreateOverlay", this_ptr_value);
    check_ptr_parameter("IVROverlay_001_CreateOverlay", (void *)1);
    check_ptr_parameter("IVROverlay_001_CreateOverlay", (void *)2);
    check_ptr_parameter("IVROverlay_001_CreateOverlay", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_001_DestroyOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_DestroyOverlay(1);
    check_ptr_parameter("IVROverlay_001_DestroyOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_DestroyOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetHighQualityOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetHighQualityOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetHighQualityOverlay(1);
    check_ptr_parameter("IVROverlay_001_SetHighQualityOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetHighQualityOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetHighQualityOverlay, 0, FALSE, FALSE);
    VROverlayHandle_t (__stdcall *capi_IVROverlay_001_GetHighQualityOverlay)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetHighQualityOverlay();
    check_ptr_parameter("IVROverlay_001_GetHighQualityOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVROverlay_001_GetOverlayErrorNameFromEnum)(VROverlayError error) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetOverlayErrorNameFromEnum(1);
    check_ptr_parameter("IVROverlay_001_GetOverlayErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVROverlay_001_GetOverlayErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayFlag, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayFlag(1, 2, 1);
    check_ptr_parameter("IVROverlay_001_SetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_001_SetOverlayFlag", 2);
    check_bool_parameter("IVROverlay_001_SetOverlayFlag", 1);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayFlag, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetOverlayFlag(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_001_GetOverlayFlag", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_GetOverlayFlag", 1);
    check_uint32_parameter("IVROverlay_001_GetOverlayFlag", 2);
    check_ptr_parameter("IVROverlay_001_GetOverlayFlag", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayAlpha, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayAlpha(1, 2.0f);
    check_ptr_parameter("IVROverlay_001_SetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayAlpha", 1);
    check_float_parameter("IVROverlay_001_SetOverlayAlpha", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayAlpha, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetOverlayAlpha(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_GetOverlayAlpha", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_GetOverlayAlpha", 1);
    check_ptr_parameter("IVROverlay_001_GetOverlayAlpha", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayGamma, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float fGamma) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayGamma(1, 2.0f);
    check_ptr_parameter("IVROverlay_001_SetOverlayGamma", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayGamma", 1);
    check_float_parameter("IVROverlay_001_SetOverlayGamma", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayGamma, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayGamma)(VROverlayHandle_t ulOverlayHandle, float * pfGamma) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetOverlayGamma(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_GetOverlayGamma", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_GetOverlayGamma", 1);
    check_ptr_parameter("IVROverlay_001_GetOverlayGamma", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayWidthInMeters, 2, TRUE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayWidthInMeters(1, 2.0f);
    check_ptr_parameter("IVROverlay_001_SetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayWidthInMeters", 1);
    check_float_parameter("IVROverlay_001_SetOverlayWidthInMeters", 2.0f);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayWidthInMeters, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetOverlayWidthInMeters(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_GetOverlayWidthInMeters", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_GetOverlayWidthInMeters", 1);
    check_ptr_parameter("IVROverlay_001_GetOverlayWidthInMeters", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayTextureBounds, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_SetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_001_SetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayTextureBounds, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetOverlayTextureBounds(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_GetOverlayTextureBounds", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_GetOverlayTextureBounds", 1);
    check_ptr_parameter("IVROverlay_001_GetOverlayTextureBounds", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayTransformType, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetOverlayTransformType(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_GetOverlayTransformType", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_GetOverlayTransformType", 1);
    check_ptr_parameter("IVROverlay_001_GetOverlayTransformType", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayTransformAbsolute(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_001_SetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayTransformAbsolute", 1);
    check_uint32_parameter("IVROverlay_001_SetOverlayTransformAbsolute", 2);
    check_ptr_parameter("IVROverlay_001_SetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, TrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_001_GetOverlayTransformAbsolute", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_GetOverlayTransformAbsolute", 1);
    check_ptr_parameter("IVROverlay_001_GetOverlayTransformAbsolute", (void *)2);
    check_ptr_parameter("IVROverlay_001_GetOverlayTransformAbsolute", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
    check_ptr_parameter("IVROverlay_001_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayTransformTrackedDeviceRelative", 1);
    check_uint32_parameter("IVROverlay_001_SetOverlayTransformTrackedDeviceRelative", 2);
    check_ptr_parameter("IVROverlay_001_SetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_001_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_GetOverlayTransformTrackedDeviceRelative", 1);
    check_ptr_parameter("IVROverlay_001_GetOverlayTransformTrackedDeviceRelative", (void *)2);
    check_ptr_parameter("IVROverlay_001_GetOverlayTransformTrackedDeviceRelative", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayVisibility, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayVisibility)(VROverlayHandle_t ulOverlayHandle, VROverlayVisibility * peOverlayVisibility) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetOverlayVisibility(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_GetOverlayVisibility", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_GetOverlayVisibility", 1);
    check_ptr_parameter("IVROverlay_001_GetOverlayVisibility", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayVisibility, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayVisibility)(VROverlayHandle_t ulOverlayHandle, VROverlayVisibility eOverlayVisibility) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayVisibility(1, 2);
    check_ptr_parameter("IVROverlay_001_SetOverlayVisibility", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayVisibility", 1);
    check_uint32_parameter("IVROverlay_001_SetOverlayVisibility", 2);

    init_thunk(t, this_ptr_value, IVROverlay_001_ShowOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_ShowOverlay(1);
    check_ptr_parameter("IVROverlay_001_ShowOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_ShowOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_001_HideOverlay, 1, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_HideOverlay(1);
    check_ptr_parameter("IVROverlay_001_HideOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_HideOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_001_IsOverlayVisible, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_001_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_IsOverlayVisible(1);
    check_ptr_parameter("IVROverlay_001_IsOverlayVisible", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_IsOverlayVisible", 1);

    init_thunk(t, this_ptr_value, IVROverlay_001_PollNextOverlayEvent, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_001_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_PollNextOverlayEvent(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_PollNextOverlayEvent", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_PollNextOverlayEvent", 1);
    check_ptr_parameter("IVROverlay_001_PollNextOverlayEvent", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayInputMethod, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetOverlayInputMethod(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_GetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_GetOverlayInputMethod", 1);
    check_ptr_parameter("IVROverlay_001_GetOverlayInputMethod", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayInputMethod, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayInputMethod(1, 2);
    check_ptr_parameter("IVROverlay_001_SetOverlayInputMethod", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayInputMethod", 1);
    check_uint32_parameter("IVROverlay_001_SetOverlayInputMethod", 2);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetOverlayMouseScale, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_GetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_GetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_001_GetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayMouseScale, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayMouseScale(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_SetOverlayMouseScale", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayMouseScale", 1);
    check_ptr_parameter("IVROverlay_001_SetOverlayMouseScale", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_ComputeOverlayIntersection, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_001_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_ComputeOverlayIntersection(1, (void *)2, (void *)3);
    check_ptr_parameter("IVROverlay_001_ComputeOverlayIntersection", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_ComputeOverlayIntersection", 1);
    check_ptr_parameter("IVROverlay_001_ComputeOverlayIntersection", (void *)2);
    check_ptr_parameter("IVROverlay_001_ComputeOverlayIntersection", (void *)3);

    init_thunk(t, this_ptr_value, IVROverlay_001_HandleControllerOverlayInteractionAsMouse, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_001_HandleControllerOverlayInteractionAsMouse)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_HandleControllerOverlayInteractionAsMouse(1, 2);
    check_ptr_parameter("IVROverlay_001_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_HandleControllerOverlayInteractionAsMouse", 1);
    check_uint32_parameter("IVROverlay_001_HandleControllerOverlayInteractionAsMouse", 2);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayTexture, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void * pTexture) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayTexture(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_SetOverlayTexture", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayTexture", 1);
    check_ptr_parameter("IVROverlay_001_SetOverlayTexture", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayRaw, 5, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayRaw(1, (void *)2, 3, 4, 5);
    check_ptr_parameter("IVROverlay_001_SetOverlayRaw", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayRaw", 1);
    check_ptr_parameter("IVROverlay_001_SetOverlayRaw", (void *)2);
    check_uint32_parameter("IVROverlay_001_SetOverlayRaw", 3);
    check_uint32_parameter("IVROverlay_001_SetOverlayRaw", 4);
    check_uint32_parameter("IVROverlay_001_SetOverlayRaw", 5);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetOverlayFromFile, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetOverlayFromFile(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_SetOverlayFromFile", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetOverlayFromFile", 1);
    check_ptr_parameter("IVROverlay_001_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVROverlay_001_IsSystemOverlayVisible, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_001_IsSystemOverlayVisible)() = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_IsSystemOverlayVisible();
    check_ptr_parameter("IVROverlay_001_IsSystemOverlayVisible", this_ptr_value);

    init_thunk(t, this_ptr_value, IVROverlay_001_IsActiveSystemOverlay, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVROverlay_001_IsActiveSystemOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_IsActiveSystemOverlay(1);
    check_ptr_parameter("IVROverlay_001_IsActiveSystemOverlay", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_IsActiveSystemOverlay", 1);

    init_thunk(t, this_ptr_value, IVROverlay_001_SetSystemOverlaySceneProcess, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_SetSystemOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_SetSystemOverlaySceneProcess(1, 2);
    check_ptr_parameter("IVROverlay_001_SetSystemOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_SetSystemOverlaySceneProcess", 1);
    check_uint32_parameter("IVROverlay_001_SetSystemOverlaySceneProcess", 2);

    init_thunk(t, this_ptr_value, IVROverlay_001_GetSystemOverlaySceneProcess, 2, FALSE, FALSE);
    VROverlayError (__stdcall *capi_IVROverlay_001_GetSystemOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;

    clear_parameters();
    capi_IVROverlay_001_GetSystemOverlaySceneProcess(1, (void *)2);
    check_ptr_parameter("IVROverlay_001_GetSystemOverlaySceneProcess", this_ptr_value);
    check_uint64_parameter("IVROverlay_001_GetSystemOverlaySceneProcess", 1);
    check_ptr_parameter("IVROverlay_001_GetSystemOverlaySceneProcess", (void *)2);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRSystem_003(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetWindowBounds, 4, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_003_GetWindowBounds)(int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetWindowBounds((void *)1, (void *)2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSystem_003_GetWindowBounds", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_GetWindowBounds", (void *)1);
    check_ptr_parameter("IVRSystem_003_GetWindowBounds", (void *)2);
    check_ptr_parameter("IVRSystem_003_GetWindowBounds", (void *)3);
    check_ptr_parameter("IVRSystem_003_GetWindowBounds", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_003_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetRecommendedRenderTargetSize((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_003_GetRecommendedRenderTargetSize", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_GetRecommendedRenderTargetSize", (void *)1);
    check_ptr_parameter("IVRSystem_003_GetRecommendedRenderTargetSize", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetEyeOutputViewport, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_003_GetEyeOutputViewport)(Hmd_Eye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetEyeOutputViewport(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_003_GetEyeOutputViewport", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetEyeOutputViewport", 1);
    check_ptr_parameter("IVRSystem_003_GetEyeOutputViewport", (void *)2);
    check_ptr_parameter("IVRSystem_003_GetEyeOutputViewport", (void *)3);
    check_ptr_parameter("IVRSystem_003_GetEyeOutputViewport", (void *)4);
    check_ptr_parameter("IVRSystem_003_GetEyeOutputViewport", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetProjectionMatrix, 5, TRUE, TRUE);
    HmdMatrix44_t *(__stdcall *capi_IVRSystem_003_GetProjectionMatrix)(HmdMatrix44_t *_r, Hmd_Eye eEye, float fNearZ, float fFarZ, GraphicsAPIConvention eProjType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f, 4);
    check_ptr_parameter("IVRSystem_003_GetProjectionMatrix", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_GetProjectionMatrix", data_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetProjectionMatrix", 1);
    check_float_parameter("IVRSystem_003_GetProjectionMatrix", 2.0f);
    check_float_parameter("IVRSystem_003_GetProjectionMatrix", 3.0f);
    check_uint32_parameter("IVRSystem_003_GetProjectionMatrix", 4);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetProjectionRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_003_GetProjectionRaw)(Hmd_Eye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
    check_ptr_parameter("IVRSystem_003_GetProjectionRaw", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetProjectionRaw", 1);
    check_ptr_parameter("IVRSystem_003_GetProjectionRaw", (void *)2);
    check_ptr_parameter("IVRSystem_003_GetProjectionRaw", (void *)3);
    check_ptr_parameter("IVRSystem_003_GetProjectionRaw", (void *)4);
    check_ptr_parameter("IVRSystem_003_GetProjectionRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_003_ComputeDistortion, 4, TRUE, TRUE);
    DistortionCoordinates_t *(__stdcall *capi_IVRSystem_003_ComputeDistortion)(DistortionCoordinates_t *_r, Hmd_Eye eEye, float fU, float fV) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_ComputeDistortion(data_ptr_value, 1, 2.0f, 3.0f);
    check_ptr_parameter("IVRSystem_003_ComputeDistortion", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_ComputeDistortion", data_ptr_value);
    check_uint32_parameter("IVRSystem_003_ComputeDistortion", 1);
    check_float_parameter("IVRSystem_003_ComputeDistortion", 2.0f);
    check_float_parameter("IVRSystem_003_ComputeDistortion", 3.0f);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetEyeToHeadTransform, 2, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_003_GetEyeToHeadTransform)(HmdMatrix34_t *_r, Hmd_Eye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetEyeToHeadTransform(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_003_GetEyeToHeadTransform", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_GetEyeToHeadTransform", data_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetEyeToHeadTransform", 1);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetTimeSinceLastVsync, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_003_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetTimeSinceLastVsync((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_003_GetTimeSinceLastVsync", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_GetTimeSinceLastVsync", (void *)1);
    check_ptr_parameter("IVRSystem_003_GetTimeSinceLastVsync", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetD3D9AdapterIndex, 0, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_003_GetD3D9AdapterIndex)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetD3D9AdapterIndex();
    check_ptr_parameter("IVRSystem_003_GetD3D9AdapterIndex", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetDXGIOutputInfo, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_003_GetDXGIOutputInfo)(int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetDXGIOutputInfo((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_003_GetDXGIOutputInfo", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_GetDXGIOutputInfo", (void *)1);
    check_ptr_parameter("IVRSystem_003_GetDXGIOutputInfo", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_003_AttachToWindow, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_003_AttachToWindow)(void * hWnd) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_AttachToWindow((void *)1);
    check_ptr_parameter("IVRSystem_003_AttachToWindow", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_AttachToWindow", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
    void (__stdcall *capi_IVRSystem_003_GetDeviceToAbsoluteTrackingPose)(TrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
    check_ptr_parameter("IVRSystem_003_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetDeviceToAbsoluteTrackingPose", 1);
    check_float_parameter("IVRSystem_003_GetDeviceToAbsoluteTrackingPose", 2.0f);
    check_ptr_parameter("IVRSystem_003_GetDeviceToAbsoluteTrackingPose", (void *)3);
    check_uint32_parameter("IVRSystem_003_GetDeviceToAbsoluteTrackingPose", 4);

    init_thunk(t, this_ptr_value, IVRSystem_003_ResetSeatedZeroPose, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_003_ResetSeatedZeroPose)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_ResetSeatedZeroPose();
    check_ptr_parameter("IVRSystem_003_ResetSeatedZeroPose", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
    check_ptr_parameter("IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_003_LoadRenderModel, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_003_LoadRenderModel)(const char * pchRenderModelName, RenderModel_t * pRenderModel) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_LoadRenderModel((void *)1, (void *)2);
    check_ptr_parameter("IVRSystem_003_LoadRenderModel", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_LoadRenderModel", (void *)1);
    check_ptr_parameter("IVRSystem_003_LoadRenderModel", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_003_FreeRenderModel, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_003_FreeRenderModel)(RenderModel_t * pRenderModel) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_FreeRenderModel((void *)1);
    check_ptr_parameter("IVRSystem_003_FreeRenderModel", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_FreeRenderModel", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetTrackedDeviceClass, 1, FALSE, FALSE);
    TrackedDeviceClass (__stdcall *capi_IVRSystem_003_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetTrackedDeviceClass(1);
    check_ptr_parameter("IVRSystem_003_GetTrackedDeviceClass", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetTrackedDeviceClass", 1);

    init_thunk(t, this_ptr_value, IVRSystem_003_IsTrackedDeviceConnected, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_003_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_IsTrackedDeviceConnected(1);
    check_ptr_parameter("IVRSystem_003_IsTrackedDeviceConnected", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_IsTrackedDeviceConnected", 1);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_003_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_003_GetBoolTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetBoolTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_003_GetBoolTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_003_GetBoolTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
    float (__stdcall *capi_IVRSystem_003_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_003_GetFloatTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetFloatTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_003_GetFloatTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_003_GetFloatTrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
    int32_t (__stdcall *capi_IVRSystem_003_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_003_GetInt32TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetInt32TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_003_GetInt32TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_003_GetInt32TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
    uint64_t (__stdcall *capi_IVRSystem_003_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_003_GetUint64TrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetUint64TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_003_GetUint64TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_003_GetUint64TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
    HmdMatrix34_t *(__stdcall *capi_IVRSystem_003_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
    check_ptr_parameter("IVRSystem_003_GetMatrix34TrackedDeviceProperty", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_GetMatrix34TrackedDeviceProperty", data_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetMatrix34TrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_003_GetMatrix34TrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_003_GetMatrix34TrackedDeviceProperty", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRSystem_003_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, TrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, TrackedPropertyError * pError) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
    check_ptr_parameter("IVRSystem_003_GetStringTrackedDeviceProperty", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetStringTrackedDeviceProperty", 1);
    check_uint32_parameter("IVRSystem_003_GetStringTrackedDeviceProperty", 2);
    check_ptr_parameter("IVRSystem_003_GetStringTrackedDeviceProperty", (void *)3);
    check_uint32_parameter("IVRSystem_003_GetStringTrackedDeviceProperty", 4);
    check_ptr_parameter("IVRSystem_003_GetStringTrackedDeviceProperty", (void *)5);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_003_GetPropErrorNameFromEnum)(TrackedPropertyError error) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetPropErrorNameFromEnum(1);
    check_ptr_parameter("IVRSystem_003_GetPropErrorNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetPropErrorNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_003_PollNextEvent, 1, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_003_PollNextEvent)(VREvent_t * pEvent) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_PollNextEvent((void *)1);
    check_ptr_parameter("IVRSystem_003_PollNextEvent", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_PollNextEvent", (void *)1);

    init_thunk(t, this_ptr_value, IVRSystem_003_PollNextEventWithPose, 3, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_003_PollNextEventWithPose)(TrackingUniverseOrigin eOrigin, VREvent_t * pEvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_PollNextEventWithPose(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRSystem_003_PollNextEventWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_PollNextEventWithPose", 1);
    check_ptr_parameter("IVRSystem_003_PollNextEventWithPose", (void *)2);
    check_ptr_parameter("IVRSystem_003_PollNextEventWithPose", (void *)3);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_003_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetEventTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_003_GetEventTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetEventTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetHiddenAreaMesh, 2, FALSE, FALSE);
    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_003_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, Hmd_Eye eEye) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetHiddenAreaMesh(data_ptr_value, 1);
    check_ptr_parameter("IVRSystem_003_GetHiddenAreaMesh", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_GetHiddenAreaMesh", data_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetHiddenAreaMesh", 1);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetControllerState, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_003_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetControllerState(1, (void *)2);
    check_ptr_parameter("IVRSystem_003_GetControllerState", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetControllerState", 1);
    check_ptr_parameter("IVRSystem_003_GetControllerState", (void *)2);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetControllerStateWithPose, 4, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_003_GetControllerStateWithPose)(TrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetControllerStateWithPose(1, 2, (void *)3, (void *)4);
    check_ptr_parameter("IVRSystem_003_GetControllerStateWithPose", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetControllerStateWithPose", 1);
    check_uint32_parameter("IVRSystem_003_GetControllerStateWithPose", 2);
    check_ptr_parameter("IVRSystem_003_GetControllerStateWithPose", (void *)3);
    check_ptr_parameter("IVRSystem_003_GetControllerStateWithPose", (void *)4);

    init_thunk(t, this_ptr_value, IVRSystem_003_TriggerHapticPulse, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_003_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_TriggerHapticPulse(1, 2, 3);
    check_ptr_parameter("IVRSystem_003_TriggerHapticPulse", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_TriggerHapticPulse", 1);
    check_uint32_parameter("IVRSystem_003_TriggerHapticPulse", 2);
    check_uint32_parameter("IVRSystem_003_TriggerHapticPulse", 3);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_003_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetButtonIdNameFromEnum(1);
    check_ptr_parameter("IVRSystem_003_GetButtonIdNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetButtonIdNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_003_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
    const char * (__stdcall *capi_IVRSystem_003_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_GetControllerAxisTypeNameFromEnum(1);
    check_ptr_parameter("IVRSystem_003_GetControllerAxisTypeNameFromEnum", this_ptr_value);
    check_uint32_parameter("IVRSystem_003_GetControllerAxisTypeNameFromEnum", 1);

    init_thunk(t, this_ptr_value, IVRSystem_003_HandleControllerOverlayInteractionAsMouse, 5, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_003_HandleControllerOverlayInteractionAsMouse)(Compositor_OverlaySettings * overlaySettings, HmdVector2_t vecWindowClientPositionOnScreen, HmdVector2_t vecWindowClientSize, TrackedDeviceIndex_t unControllerDeviceIndex, EVRControllerEventOutputType eOutputType) = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_HandleControllerOverlayInteractionAsMouse((void *)1, DEFAULT_VECTOR2, DEFAULT_VECTOR2, 4, 5);
    check_ptr_parameter("IVRSystem_003_HandleControllerOverlayInteractionAsMouse", this_ptr_value);
    check_ptr_parameter("IVRSystem_003_HandleControllerOverlayInteractionAsMouse", (void *)1);
    check_HmdVector2_parameter("IVRSystem_003_HandleControllerOverlayInteractionAsMouse", DEFAULT_VECTOR2);
    check_HmdVector2_parameter("IVRSystem_003_HandleControllerOverlayInteractionAsMouse", DEFAULT_VECTOR2);
    check_uint32_parameter("IVRSystem_003_HandleControllerOverlayInteractionAsMouse", 4);
    check_uint32_parameter("IVRSystem_003_HandleControllerOverlayInteractionAsMouse", 5);

    init_thunk(t, this_ptr_value, IVRSystem_003_CaptureInputFocus, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_003_CaptureInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_CaptureInputFocus();
    check_ptr_parameter("IVRSystem_003_CaptureInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_003_ReleaseInputFocus, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRSystem_003_ReleaseInputFocus)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_ReleaseInputFocus();
    check_ptr_parameter("IVRSystem_003_ReleaseInputFocus", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRSystem_003_IsInputFocusCapturedByAnotherProcess, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRSystem_003_IsInputFocusCapturedByAnotherProcess)() = (void *)t;

    clear_parameters();
    capi_IVRSystem_003_IsInputFocusCapturedByAnotherProcess();
    check_ptr_parameter("IVRSystem_003_IsInputFocusCapturedByAnotherProcess", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}

void test_capi_thunks_IVRCompositor_005(void)
{
    struct thunk *t = alloc_thunks(1);

    init_thunk(t, this_ptr_value, IVRCompositor_005_GetLastError, 2, FALSE, FALSE);
    uint32_t (__stdcall *capi_IVRCompositor_005_GetLastError)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_GetLastError((void *)1, 2);
    check_ptr_parameter("IVRCompositor_005_GetLastError", this_ptr_value);
    check_ptr_parameter("IVRCompositor_005_GetLastError", (void *)1);
    check_uint32_parameter("IVRCompositor_005_GetLastError", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_005_SetVSync, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_SetVSync)(bool bVSync) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_SetVSync(1);
    check_ptr_parameter("IVRCompositor_005_SetVSync", this_ptr_value);
    check_bool_parameter("IVRCompositor_005_SetVSync", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_005_GetVSync, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_005_GetVSync)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_GetVSync();
    check_ptr_parameter("IVRCompositor_005_GetVSync", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_005_SetGamma, 1, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_SetGamma)(float fGamma) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_SetGamma(1.0f);
    check_ptr_parameter("IVRCompositor_005_SetGamma", this_ptr_value);
    check_float_parameter("IVRCompositor_005_SetGamma", 1.0f);

    init_thunk(t, this_ptr_value, IVRCompositor_005_GetGamma, 0, FALSE, FALSE);
    float (__stdcall *capi_IVRCompositor_005_GetGamma)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_GetGamma();
    check_ptr_parameter("IVRCompositor_005_GetGamma", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_005_SetGraphicsDevice, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_SetGraphicsDevice)(Compositor_DeviceType eType, void * pDevice) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_SetGraphicsDevice(1, (void *)2);
    check_ptr_parameter("IVRCompositor_005_SetGraphicsDevice", this_ptr_value);
    check_uint32_parameter("IVRCompositor_005_SetGraphicsDevice", 1);
    check_ptr_parameter("IVRCompositor_005_SetGraphicsDevice", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_005_WaitGetPoses, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_WaitGetPoses)(TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_WaitGetPoses((void *)1, 2);
    check_ptr_parameter("IVRCompositor_005_WaitGetPoses", this_ptr_value);
    check_ptr_parameter("IVRCompositor_005_WaitGetPoses", (void *)1);
    check_uint32_parameter("IVRCompositor_005_WaitGetPoses", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_005_Submit, 3, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_Submit)(Hmd_Eye eEye, void * pTexture, Compositor_TextureBounds * pBounds) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_Submit(1, (void *)2, (void *)3);
    check_ptr_parameter("IVRCompositor_005_Submit", this_ptr_value);
    check_uint32_parameter("IVRCompositor_005_Submit", 1);
    check_ptr_parameter("IVRCompositor_005_Submit", (void *)2);
    check_ptr_parameter("IVRCompositor_005_Submit", (void *)3);

    init_thunk(t, this_ptr_value, IVRCompositor_005_ClearLastSubmittedFrame, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_ClearLastSubmittedFrame)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_ClearLastSubmittedFrame();
    check_ptr_parameter("IVRCompositor_005_ClearLastSubmittedFrame", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_005_GetOverlayDefaults, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_GetOverlayDefaults)(Compositor_OverlaySettings * pSettings) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_GetOverlayDefaults((void *)1);
    check_ptr_parameter("IVRCompositor_005_GetOverlayDefaults", this_ptr_value);
    check_ptr_parameter("IVRCompositor_005_GetOverlayDefaults", (void *)1);

    init_thunk(t, this_ptr_value, IVRCompositor_005_SetOverlay, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_SetOverlay)(void * pTexture, Compositor_OverlaySettings * pSettings) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_SetOverlay((void *)1, (void *)2);
    check_ptr_parameter("IVRCompositor_005_SetOverlay", this_ptr_value);
    check_ptr_parameter("IVRCompositor_005_SetOverlay", (void *)1);
    check_ptr_parameter("IVRCompositor_005_SetOverlay", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_005_SetOverlayRaw, 5, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_SetOverlayRaw)(void * buffer, uint32_t width, uint32_t height, uint32_t depth, Compositor_OverlaySettings * pSettings) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_SetOverlayRaw((void *)1, 2, 3, 4, (void *)5);
    check_ptr_parameter("IVRCompositor_005_SetOverlayRaw", this_ptr_value);
    check_ptr_parameter("IVRCompositor_005_SetOverlayRaw", (void *)1);
    check_uint32_parameter("IVRCompositor_005_SetOverlayRaw", 2);
    check_uint32_parameter("IVRCompositor_005_SetOverlayRaw", 3);
    check_uint32_parameter("IVRCompositor_005_SetOverlayRaw", 4);
    check_ptr_parameter("IVRCompositor_005_SetOverlayRaw", (void *)5);

    init_thunk(t, this_ptr_value, IVRCompositor_005_SetOverlayFromFile, 2, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_SetOverlayFromFile)(const char * pchFilePath, Compositor_OverlaySettings * pSettings) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_SetOverlayFromFile((void *)1, (void *)2);
    check_ptr_parameter("IVRCompositor_005_SetOverlayFromFile", this_ptr_value);
    check_ptr_parameter("IVRCompositor_005_SetOverlayFromFile", (void *)1);
    check_ptr_parameter("IVRCompositor_005_SetOverlayFromFile", (void *)2);

    init_thunk(t, this_ptr_value, IVRCompositor_005_ClearOverlay, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_ClearOverlay)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_ClearOverlay();
    check_ptr_parameter("IVRCompositor_005_ClearOverlay", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_005_GetFrameTiming, 2, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_005_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_GetFrameTiming((void *)1, 2);
    check_ptr_parameter("IVRCompositor_005_GetFrameTiming", this_ptr_value);
    check_ptr_parameter("IVRCompositor_005_GetFrameTiming", (void *)1);
    check_uint32_parameter("IVRCompositor_005_GetFrameTiming", 2);

    init_thunk(t, this_ptr_value, IVRCompositor_005_FadeToColor, 6, TRUE, TRUE);
    void (__stdcall *capi_IVRCompositor_005_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
    check_ptr_parameter("IVRCompositor_005_FadeToColor", this_ptr_value);
    check_float_parameter("IVRCompositor_005_FadeToColor", 1.0f);
    check_float_parameter("IVRCompositor_005_FadeToColor", 2.0f);
    check_float_parameter("IVRCompositor_005_FadeToColor", 3.0f);
    check_float_parameter("IVRCompositor_005_FadeToColor", 4.0f);
    check_float_parameter("IVRCompositor_005_FadeToColor", 5.0f);
    check_bool_parameter("IVRCompositor_005_FadeToColor", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_005_FadeGrid, 2, TRUE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_FadeGrid(1.0f, 1);
    check_ptr_parameter("IVRCompositor_005_FadeGrid", this_ptr_value);
    check_float_parameter("IVRCompositor_005_FadeGrid", 1.0f);
    check_bool_parameter("IVRCompositor_005_FadeGrid", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_005_CompositorBringToFront, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_CompositorBringToFront)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_CompositorBringToFront();
    check_ptr_parameter("IVRCompositor_005_CompositorBringToFront", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_005_CompositorGoToBack, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_CompositorGoToBack)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_CompositorGoToBack();
    check_ptr_parameter("IVRCompositor_005_CompositorGoToBack", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_005_CompositorQuit, 0, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_CompositorQuit)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_CompositorQuit();
    check_ptr_parameter("IVRCompositor_005_CompositorQuit", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_005_IsFullscreen, 0, FALSE, FALSE);
    bool (__stdcall *capi_IVRCompositor_005_IsFullscreen)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_IsFullscreen();
    check_ptr_parameter("IVRCompositor_005_IsFullscreen", this_ptr_value);

    init_thunk(t, this_ptr_value, IVRCompositor_005_ComputeOverlayIntersection, 7, TRUE, FALSE);
    bool (__stdcall *capi_IVRCompositor_005_ComputeOverlayIntersection)(Compositor_OverlaySettings * pSettings, float fAspectRatio, TrackingUniverseOrigin eOrigin, HmdVector3_t vSource, HmdVector3_t vDirection, HmdVector2_t * pvecIntersectionUV, HmdVector3_t * pvecIntersectionTrackingSpace) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_ComputeOverlayIntersection((void *)1, 2.0f, 3, DEFAULT_VECTOR3, DEFAULT_VECTOR3, (void *)6, (void *)7);
    check_ptr_parameter("IVRCompositor_005_ComputeOverlayIntersection", this_ptr_value);
    check_ptr_parameter("IVRCompositor_005_ComputeOverlayIntersection", (void *)1);
    check_float_parameter("IVRCompositor_005_ComputeOverlayIntersection", 2.0f);
    check_uint32_parameter("IVRCompositor_005_ComputeOverlayIntersection", 3);
    check_HmdVector3_parameter("IVRCompositor_005_ComputeOverlayIntersection", DEFAULT_VECTOR3);
    check_HmdVector3_parameter("IVRCompositor_005_ComputeOverlayIntersection", DEFAULT_VECTOR3);
    check_ptr_parameter("IVRCompositor_005_ComputeOverlayIntersection", (void *)6);
    check_ptr_parameter("IVRCompositor_005_ComputeOverlayIntersection", (void *)7);

    init_thunk(t, this_ptr_value, IVRCompositor_005_SetTrackingSpace, 1, FALSE, FALSE);
    void (__stdcall *capi_IVRCompositor_005_SetTrackingSpace)(TrackingUniverseOrigin eOrigin) = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_SetTrackingSpace(1);
    check_ptr_parameter("IVRCompositor_005_SetTrackingSpace", this_ptr_value);
    check_uint32_parameter("IVRCompositor_005_SetTrackingSpace", 1);

    init_thunk(t, this_ptr_value, IVRCompositor_005_GetTrackingSpace, 0, FALSE, FALSE);
    TrackingUniverseOrigin (__stdcall *capi_IVRCompositor_005_GetTrackingSpace)() = (void *)t;

    clear_parameters();
    capi_IVRCompositor_005_GetTrackingSpace();
    check_ptr_parameter("IVRCompositor_005_GetTrackingSpace", this_ptr_value);
    VirtualFree(t, 0, MEM_RELEASE);
}
