kc3-lang/angle/util/capture/trace_interpreter_autogen.cpp

• Show log

  Commit

• Hash : 5b343e8f
  Author :
  Date : 2025-03-11T11:35:08
  

  Vulkan: Remove support for Stadia
  
  Bug: angleproject:42262714
  Change-Id: Icae5fe828fe4e0bcd287d297df1bc586708ef86e
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6344390
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
  

Download

• util/capture/trace_interpreter_autogen.cpp

• // GENERATED FILE - DO NOT EDIT.
  // Generated by gen_interpreter_utils.py using data from gl.xml and gl_angle_ext.xml.
  //
  // Copyright 2022 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // trace_interpreter_autogen.cpp:
  //   Helper code for trace interpreter.
  
  #include "angle_trace_gl.h"
  #include "trace_fixture.h"
  #include "trace_interpreter.h"
  
  namespace angle
  {
  CallCapture ParseCallCapture(const Token &nameToken,
                               size_t numParamTokens,
                               const Token *paramTokens,
                               const TraceStringMap &strings)
  {
      if (strcmp(nameToken, "eglAcquireExternalContextANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLACQUIREEXTERNALCONTEXTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLAcquireExternalContextANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglBindAPI") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLBINDAPIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLBindAPI, std::move(params));
      }
      if (strcmp(nameToken, "eglBindTexImage") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLBINDTEXIMAGEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLBindTexImage, std::move(params));
      }
      if (strcmp(nameToken, "eglChooseConfig") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLCHOOSECONFIGPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLChooseConfig, std::move(params));
      }
      if (strcmp(nameToken, "eglClientWaitSync") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLCLIENTWAITSYNCPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLClientWaitSync, std::move(params));
      }
      if (strcmp(nameToken, "eglClientWaitSyncKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCLIENTWAITSYNCKHRPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::EGLClientWaitSyncKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglCopyBuffers") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCOPYBUFFERSPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLCopyBuffers, std::move(params));
      }
      if (strcmp(nameToken, "eglCopyMetalSharedEventANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCOPYMETALSHAREDEVENTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLCopyMetalSharedEventANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglCreateContext") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLCREATECONTEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLCreateContext, std::move(params));
      }
      if (strcmp(nameToken, "eglCreateDeviceANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCREATEDEVICEANGLEPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::EGLCreateDeviceANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglCreateImage") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCREATEIMAGEPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLCreateImage, std::move(params));
      }
      if (strcmp(nameToken, "eglCreateImageKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLCREATEIMAGEKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLCreateImageKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglCreateNativeClientBufferANDROID") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLCreateNativeClientBufferANDROID, std::move(params));
      }
      if (strcmp(nameToken, "eglCreatePbufferFromClientBuffer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLCreatePbufferFromClientBuffer, std::move(params));
      }
      if (strcmp(nameToken, "eglCreatePbufferSurface") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCREATEPBUFFERSURFACEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::EGLCreatePbufferSurface, std::move(params));
      }
      if (strcmp(nameToken, "eglCreatePixmapSurface") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCREATEPIXMAPSURFACEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::EGLCreatePixmapSurface, std::move(params));
      }
      if (strcmp(nameToken, "eglCreatePlatformPixmapSurface") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLCreatePlatformPixmapSurface, std::move(params));
      }
      if (strcmp(nameToken, "eglCreatePlatformPixmapSurfaceEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLCreatePlatformPixmapSurfaceEXT, std::move(params));
      }
      if (strcmp(nameToken, "eglCreatePlatformWindowSurface") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCREATEPLATFORMWINDOWSURFACEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLCreatePlatformWindowSurface, std::move(params));
      }
      if (strcmp(nameToken, "eglCreatePlatformWindowSurfaceEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLCreatePlatformWindowSurfaceEXT, std::move(params));
      }
      if (strcmp(nameToken, "eglCreateStreamKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLCREATESTREAMKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLCreateStreamKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglCreateStreamProducerD3DTextureANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNEGLCREATESTREAMPRODUCERD3DTEXTUREANGLEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::EGLCreateStreamProducerD3DTextureANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglCreateSync") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCREATESYNCPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLCreateSync, std::move(params));
      }
      if (strcmp(nameToken, "eglCreateSyncKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLCREATESYNCKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLCreateSyncKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglCreateWindowSurface") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLCREATEWINDOWSURFACEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::EGLCreateWindowSurface, std::move(params));
      }
      if (strcmp(nameToken, "eglDebugMessageControlKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLDEBUGMESSAGECONTROLKHRPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLDebugMessageControlKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglDestroyContext") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLDESTROYCONTEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLDestroyContext, std::move(params));
      }
      if (strcmp(nameToken, "eglDestroyImage") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLDESTROYIMAGEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLDestroyImage, std::move(params));
      }
      if (strcmp(nameToken, "eglDestroyImageKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLDESTROYIMAGEKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLDestroyImageKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglDestroyStreamKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLDESTROYSTREAMKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLDestroyStreamKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglDestroySurface") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLDESTROYSURFACEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLDestroySurface, std::move(params));
      }
      if (strcmp(nameToken, "eglDestroySync") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLDESTROYSYNCPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLDestroySync, std::move(params));
      }
      if (strcmp(nameToken, "eglDestroySyncKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLDESTROYSYNCKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLDestroySyncKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglDupNativeFenceFDANDROID") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLDUPNATIVEFENCEFDANDROIDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLDupNativeFenceFDANDROID, std::move(params));
      }
      if (strcmp(nameToken, "eglExportVkImageANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLEXPORTVKIMAGEANGLEPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::EGLExportVkImageANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglForceGPUSwitchANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLFORCEGPUSWITCHANGLEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::EGLForceGPUSwitchANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglGetCompositorTimingANDROID") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETCOMPOSITORTIMINGANDROIDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLGetCompositorTimingANDROID, std::move(params));
      }
      if (strcmp(nameToken, "eglGetCompositorTimingSupportedANDROID") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::EGLGetCompositorTimingSupportedANDROID, std::move(params));
      }
      if (strcmp(nameToken, "eglGetConfigAttrib") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLGETCONFIGATTRIBPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLGetConfigAttrib, std::move(params));
      }
      if (strcmp(nameToken, "eglGetConfigs") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETCONFIGSPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLGetConfigs, std::move(params));
      }
      if (strcmp(nameToken, "eglGetCurrentContext") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETCURRENTCONTEXTPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::EGLGetCurrentContext, std::move(params));
      }
      if (strcmp(nameToken, "eglGetCurrentDisplay") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETCURRENTDISPLAYPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::EGLGetCurrentDisplay, std::move(params));
      }
      if (strcmp(nameToken, "eglGetCurrentSurface") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETCURRENTSURFACEPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::EGLGetCurrentSurface, std::move(params));
      }
      if (strcmp(nameToken, "eglGetDisplay") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETDISPLAYPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLGetDisplay, std::move(params));
      }
      if (strcmp(nameToken, "eglGetError") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETERRORPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLGetError, std::move(params));
      }
      if (strcmp(nameToken, "eglGetFrameTimestampSupportedANDROID") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLGetFrameTimestampSupportedANDROID, std::move(params));
      }
      if (strcmp(nameToken, "eglGetFrameTimestampsANDROID") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETFRAMETIMESTAMPSANDROIDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLGetFrameTimestampsANDROID, std::move(params));
      }
      if (strcmp(nameToken, "eglGetMscRateANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLGETMSCRATEANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLGetMscRateANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglGetNativeClientBufferANDROID") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLGetNativeClientBufferANDROID, std::move(params));
      }
      if (strcmp(nameToken, "eglGetNextFrameIdANDROID") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETNEXTFRAMEIDANDROIDPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::EGLGetNextFrameIdANDROID, std::move(params));
      }
      if (strcmp(nameToken, "eglGetPlatformDisplay") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETPLATFORMDISPLAYPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::EGLGetPlatformDisplay, std::move(params));
      }
      if (strcmp(nameToken, "eglGetPlatformDisplayEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETPLATFORMDISPLAYEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::EGLGetPlatformDisplayEXT, std::move(params));
      }
      if (strcmp(nameToken, "eglGetProcAddress") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLGETPROCADDRESSPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLGetProcAddress, std::move(params));
      }
      if (strcmp(nameToken, "eglGetSyncAttrib") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLGETSYNCATTRIBPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLGetSyncAttrib, std::move(params));
      }
      if (strcmp(nameToken, "eglGetSyncAttribKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLGETSYNCATTRIBKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLGetSyncAttribKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglGetSyncValuesCHROMIUM") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLGETSYNCVALUESCHROMIUMPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::EGLGetSyncValuesCHROMIUM, std::move(params));
      }
      if (strcmp(nameToken, "eglHandleGPUSwitchANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLHANDLEGPUSWITCHANGLEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::EGLHandleGPUSwitchANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglInitialize") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLINITIALIZEPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLInitialize, std::move(params));
      }
      if (strcmp(nameToken, "eglLabelObjectKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLLABELOBJECTKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLLabelObjectKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglLockSurfaceKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLLOCKSURFACEKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLLockSurfaceKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglLockVulkanQueueANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLLOCKVULKANQUEUEANGLEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::EGLLockVulkanQueueANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglMakeCurrent") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLMAKECURRENTPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLMakeCurrent, std::move(params));
      }
      if (strcmp(nameToken, "eglPostSubBufferNV") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLPOSTSUBBUFFERNVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLPostSubBufferNV, std::move(params));
      }
      if (strcmp(nameToken, "eglPrepareSwapBuffersANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLPREPARESWAPBUFFERSANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLPrepareSwapBuffersANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglPresentationTimeANDROID") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLPRESENTATIONTIMEANDROIDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLPresentationTimeANDROID, std::move(params));
      }
      if (strcmp(nameToken, "eglProgramCacheGetAttribANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLPROGRAMCACHEGETATTRIBANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLProgramCacheGetAttribANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglProgramCachePopulateANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLPROGRAMCACHEPOPULATEANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLProgramCachePopulateANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglProgramCacheQueryANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLPROGRAMCACHEQUERYANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLProgramCacheQueryANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglProgramCacheResizeANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLPROGRAMCACHERESIZEANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLProgramCacheResizeANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryAPI") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYAPIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLQueryAPI, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryContext") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLQUERYCONTEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLQueryContext, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryDebugKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLQUERYDEBUGKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLQueryDebugKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryDeviceAttribEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYDEVICEATTRIBEXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::EGLQueryDeviceAttribEXT, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryDeviceStringEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYDEVICESTRINGEXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::EGLQueryDeviceStringEXT, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryDisplayAttribANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYDISPLAYATTRIBANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLQueryDisplayAttribANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryDisplayAttribEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYDISPLAYATTRIBEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::EGLQueryDisplayAttribEXT, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryDmaBufFormatsEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYDMABUFFORMATSEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::EGLQueryDmaBufFormatsEXT, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryDmaBufModifiersEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYDMABUFMODIFIERSEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLQueryDmaBufModifiersEXT, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryStreamKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLQUERYSTREAMKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLQueryStreamKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryStreamu64KHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYSTREAMU64KHRPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::EGLQueryStreamu64KHR, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryString") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYSTRINGPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLQueryString, std::move(params));
      }
      if (strcmp(nameToken, "eglQueryStringiANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYSTRINGIANGLEPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::EGLQueryStringiANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglQuerySupportedCompressionRatesEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYSUPPORTEDCOMPRESSIONRATESEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLQuerySupportedCompressionRatesEXT, std::move(params));
      }
      if (strcmp(nameToken, "eglQuerySurface") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLQUERYSURFACEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLQuerySurface, std::move(params));
      }
      if (strcmp(nameToken, "eglQuerySurface64KHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYSURFACE64KHRPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::EGLQuerySurface64KHR, std::move(params));
      }
      if (strcmp(nameToken, "eglQuerySurfacePointerANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLQUERYSURFACEPOINTERANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLQuerySurfacePointerANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglReacquireHighPowerGPUANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLREACQUIREHIGHPOWERGPUANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLReacquireHighPowerGPUANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglReleaseDeviceANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLRELEASEDEVICEANGLEPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::EGLReleaseDeviceANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglReleaseExternalContextANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLRELEASEEXTERNALCONTEXTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLReleaseExternalContextANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglReleaseHighPowerGPUANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLRELEASEHIGHPOWERGPUANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLReleaseHighPowerGPUANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglReleaseTexImage") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLRELEASETEXIMAGEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLReleaseTexImage, std::move(params));
      }
      if (strcmp(nameToken, "eglReleaseThread") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLRELEASETHREADPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLReleaseThread, std::move(params));
      }
      if (strcmp(nameToken, "eglSetBlobCacheFuncsANDROID") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLSETBLOBCACHEFUNCSANDROIDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLSetBlobCacheFuncsANDROID, std::move(params));
      }
      if (strcmp(nameToken, "eglSetDamageRegionKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLSETDAMAGEREGIONKHRPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::EGLSetDamageRegionKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglSetValidationEnabledANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLSETVALIDATIONENABLEDANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLSetValidationEnabledANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglSignalSyncKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLSIGNALSYNCKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLSignalSyncKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglStreamAttribKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLSTREAMATTRIBKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLStreamAttribKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglStreamConsumerAcquireKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLSTREAMCONSUMERACQUIREKHRPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLStreamConsumerAcquireKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglStreamConsumerGLTextureExternalAttribsNV") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLStreamConsumerGLTextureExternalAttribsNV,
                             std::move(params));
      }
      if (strcmp(nameToken, "eglStreamConsumerGLTextureExternalKHR") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::EGLStreamConsumerGLTextureExternalKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglStreamConsumerReleaseKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLSTREAMCONSUMERRELEASEKHRPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLStreamConsumerReleaseKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglStreamPostD3DTextureANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLSTREAMPOSTD3DTEXTUREANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLStreamPostD3DTextureANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglSurfaceAttrib") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLSURFACEATTRIBPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLSurfaceAttrib, std::move(params));
      }
      if (strcmp(nameToken, "eglSwapBuffers") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLSWAPBUFFERSPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLSwapBuffers, std::move(params));
      }
      if (strcmp(nameToken, "eglSwapBuffersWithDamageKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLSwapBuffersWithDamageKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglSwapInterval") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLSWAPINTERVALPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLSwapInterval, std::move(params));
      }
      if (strcmp(nameToken, "eglTerminate") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLTERMINATEPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLTerminate, std::move(params));
      }
      if (strcmp(nameToken, "eglUnlockSurfaceKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLUNLOCKSURFACEKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::EGLUnlockSurfaceKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglUnlockVulkanQueueANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLUNLOCKVULKANQUEUEANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLUnlockVulkanQueueANGLE, std::move(params));
      }
      if (strcmp(nameToken, "eglWaitClient") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLWAITCLIENTPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLWaitClient, std::move(params));
      }
      if (strcmp(nameToken, "eglWaitGL") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLWAITGLPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLWaitGL, std::move(params));
      }
      if (strcmp(nameToken, "eglWaitNative") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLWAITNATIVEPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLWaitNative, std::move(params));
      }
      if (strcmp(nameToken, "eglWaitSync") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLWAITSYNCPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLWaitSync, std::move(params));
      }
      if (strcmp(nameToken, "eglWaitSyncKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLWAITSYNCKHRPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::EGLWaitSyncKHR, std::move(params));
      }
      if (strcmp(nameToken, "eglWaitUntilWorkScheduledANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNEGLWAITUNTILWORKSCHEDULEDANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::EGLWaitUntilWorkScheduledANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glAcquireTexturesANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLACQUIRETEXTURESANGLEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLAcquireTexturesANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glActiveShaderProgram") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLACTIVESHADERPROGRAMPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLActiveShaderProgram, std::move(params));
      }
      if (strcmp(nameToken, "glActiveShaderProgramEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLACTIVESHADERPROGRAMEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLActiveShaderProgramEXT, std::move(params));
      }
      if (strcmp(nameToken, "glActiveTexture") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLACTIVETEXTUREPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLActiveTexture, std::move(params));
      }
      if (strcmp(nameToken, "glAlphaFunc") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLALPHAFUNCPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLAlphaFunc, std::move(params));
      }
      if (strcmp(nameToken, "glAlphaFuncx") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLALPHAFUNCXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLAlphaFuncx, std::move(params));
      }
      if (strcmp(nameToken, "glAttachShader") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLATTACHSHADERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLAttachShader, std::move(params));
      }
      if (strcmp(nameToken, "glBeginPerfMonitorAMD") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBEGINPERFMONITORAMDPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLBeginPerfMonitorAMD, std::move(params));
      }
      if (strcmp(nameToken, "glBeginPixelLocalStorageANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBEGINPIXELLOCALSTORAGEANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLBeginPixelLocalStorageANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glBeginQuery") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBEGINQUERYPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLBeginQuery, std::move(params));
      }
      if (strcmp(nameToken, "glBeginQueryEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBEGINQUERYEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBeginQueryEXT, std::move(params));
      }
      if (strcmp(nameToken, "glBeginTransformFeedback") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBEGINTRANSFORMFEEDBACKPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLBeginTransformFeedback, std::move(params));
      }
      if (strcmp(nameToken, "glBindAttribLocation") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDATTRIBLOCATIONPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLBindAttribLocation, std::move(params));
      }
      if (strcmp(nameToken, "glBindBuffer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDBUFFERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLBindBuffer, std::move(params));
      }
      if (strcmp(nameToken, "glBindBufferBase") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDBUFFERBASEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBindBufferBase, std::move(params));
      }
      if (strcmp(nameToken, "glBindBufferRange") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDBUFFERRANGEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBindBufferRange, std::move(params));
      }
      if (strcmp(nameToken, "glBindFragDataLocationEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDFRAGDATALOCATIONEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLBindFragDataLocationEXT, std::move(params));
      }
      if (strcmp(nameToken, "glBindFragDataLocationIndexedEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLBindFragDataLocationIndexedEXT, std::move(params));
      }
      if (strcmp(nameToken, "glBindFramebuffer") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDFRAMEBUFFERPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBindFramebuffer, std::move(params));
      }
      if (strcmp(nameToken, "glBindFramebufferOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDFRAMEBUFFEROESPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLBindFramebufferOES, std::move(params));
      }
      if (strcmp(nameToken, "glBindImageTexture") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDIMAGETEXTUREPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBindImageTexture, std::move(params));
      }
      if (strcmp(nameToken, "glBindProgramPipeline") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDPROGRAMPIPELINEPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLBindProgramPipeline, std::move(params));
      }
      if (strcmp(nameToken, "glBindProgramPipelineEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDPROGRAMPIPELINEEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLBindProgramPipelineEXT, std::move(params));
      }
      if (strcmp(nameToken, "glBindRenderbuffer") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDRENDERBUFFERPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBindRenderbuffer, std::move(params));
      }
      if (strcmp(nameToken, "glBindRenderbufferOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDRENDERBUFFEROESPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLBindRenderbufferOES, std::move(params));
      }
      if (strcmp(nameToken, "glBindSampler") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDSAMPLERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLBindSampler, std::move(params));
      }
      if (strcmp(nameToken, "glBindTexture") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDTEXTUREPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLBindTexture, std::move(params));
      }
      if (strcmp(nameToken, "glBindTransformFeedback") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDTRANSFORMFEEDBACKPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLBindTransformFeedback, std::move(params));
      }
      if (strcmp(nameToken, "glBindUniformLocationCHROMIUM") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDUNIFORMLOCATIONCHROMIUMPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLBindUniformLocationCHROMIUM, std::move(params));
      }
      if (strcmp(nameToken, "glBindVertexArray") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDVERTEXARRAYPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBindVertexArray, std::move(params));
      }
      if (strcmp(nameToken, "glBindVertexArrayOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBINDVERTEXARRAYOESPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLBindVertexArrayOES, std::move(params));
      }
      if (strcmp(nameToken, "glBindVertexBuffer") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDVERTEXBUFFERPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBindVertexBuffer, std::move(params));
      }
      if (strcmp(nameToken, "glBlendBarrier") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLENDBARRIERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendBarrier, std::move(params));
      }
      if (strcmp(nameToken, "glBlendBarrierKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDBARRIERKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendBarrierKHR, std::move(params));
      }
      if (strcmp(nameToken, "glBlendColor") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLENDCOLORPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendColor, std::move(params));
      }
      if (strcmp(nameToken, "glBlendEquation") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendEquation, std::move(params));
      }
      if (strcmp(nameToken, "glBlendEquationOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendEquationOES, std::move(params));
      }
      if (strcmp(nameToken, "glBlendEquationSeparate") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONSEPARATEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLBlendEquationSeparate, std::move(params));
      }
      if (strcmp(nameToken, "glBlendEquationSeparatei") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONSEPARATEIPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLBlendEquationSeparatei, std::move(params));
      }
      if (strcmp(nameToken, "glBlendEquationSeparateiEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONSEPARATEIEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendEquationSeparateiEXT, std::move(params));
      }
      if (strcmp(nameToken, "glBlendEquationSeparateiOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONSEPARATEIOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendEquationSeparateiOES, std::move(params));
      }
      if (strcmp(nameToken, "glBlendEquationi") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONIPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendEquationi, std::move(params));
      }
      if (strcmp(nameToken, "glBlendEquationiEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONIEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendEquationiEXT, std::move(params));
      }
      if (strcmp(nameToken, "glBlendEquationiOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONIOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendEquationiOES, std::move(params));
      }
      if (strcmp(nameToken, "glBlendFunc") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLENDFUNCPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendFunc, std::move(params));
      }
      if (strcmp(nameToken, "glBlendFuncSeparate") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDFUNCSEPARATEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendFuncSeparate, std::move(params));
      }
      if (strcmp(nameToken, "glBlendFuncSeparatei") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLENDFUNCSEPARATEIPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLBlendFuncSeparatei, std::move(params));
      }
      if (strcmp(nameToken, "glBlendFuncSeparateiEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLENDFUNCSEPARATEIEXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLBlendFuncSeparateiEXT, std::move(params));
      }
      if (strcmp(nameToken, "glBlendFuncSeparateiOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLENDFUNCSEPARATEIOESPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLBlendFuncSeparateiOES, std::move(params));
      }
      if (strcmp(nameToken, "glBlendFunci") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLENDFUNCIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendFunci, std::move(params));
      }
      if (strcmp(nameToken, "glBlendFunciEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDFUNCIEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendFunciEXT, std::move(params));
      }
      if (strcmp(nameToken, "glBlendFunciOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDFUNCIOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBlendFunciOES, std::move(params));
      }
      if (strcmp(nameToken, "glBlitFramebuffer") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLITFRAMEBUFFERPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBlitFramebuffer, std::move(params));
      }
      if (strcmp(nameToken, "glBlitFramebufferANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLITFRAMEBUFFERANGLEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLBlitFramebufferANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glBlitFramebufferNV") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLITFRAMEBUFFERNVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBlitFramebufferNV, std::move(params));
      }
      if (strcmp(nameToken, "glBlobCacheCallbacksANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBLOBCACHECALLBACKSANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLBlobCacheCallbacksANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glBufferData") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBUFFERDATAPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLBufferData, std::move(params));
      }
      if (strcmp(nameToken, "glBufferStorageEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBUFFERSTORAGEEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBufferStorageEXT, std::move(params));
      }
      if (strcmp(nameToken, "glBufferStorageExternalEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBUFFERSTORAGEEXTERNALEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLBufferStorageExternalEXT, std::move(params));
      }
      if (strcmp(nameToken, "glBufferStorageMemEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLBUFFERSTORAGEMEMEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLBufferStorageMemEXT, std::move(params));
      }
      if (strcmp(nameToken, "glBufferSubData") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBUFFERSUBDATAPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLBufferSubData, std::move(params));
      }
      if (strcmp(nameToken, "glCheckFramebufferStatus") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCHECKFRAMEBUFFERSTATUSPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLCheckFramebufferStatus, std::move(params));
      }
      if (strcmp(nameToken, "glCheckFramebufferStatusOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCHECKFRAMEBUFFERSTATUSOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCheckFramebufferStatusOES, std::move(params));
      }
      if (strcmp(nameToken, "glClear") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCLEARPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLClear, std::move(params));
      }
      if (strcmp(nameToken, "glClearBufferfi") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLEARBUFFERFIPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLClearBufferfi, std::move(params));
      }
      if (strcmp(nameToken, "glClearBufferfv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLEARBUFFERFVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLClearBufferfv, std::move(params));
      }
      if (strcmp(nameToken, "glClearBufferiv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLEARBUFFERIVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLClearBufferiv, std::move(params));
      }
      if (strcmp(nameToken, "glClearBufferuiv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLEARBUFFERUIVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLClearBufferuiv, std::move(params));
      }
      if (strcmp(nameToken, "glClearColor") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCLEARCOLORPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLClearColor, std::move(params));
      }
      if (strcmp(nameToken, "glClearColorx") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCLEARCOLORXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLClearColorx, std::move(params));
      }
      if (strcmp(nameToken, "glClearDepthf") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCLEARDEPTHFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLClearDepthf, std::move(params));
      }
      if (strcmp(nameToken, "glClearDepthx") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCLEARDEPTHXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLClearDepthx, std::move(params));
      }
      if (strcmp(nameToken, "glClearStencil") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCLEARSTENCILPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLClearStencil, std::move(params));
      }
      if (strcmp(nameToken, "glClearTexImageEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLEARTEXIMAGEEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLClearTexImageEXT, std::move(params));
      }
      if (strcmp(nameToken, "glClearTexSubImageEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCLEARTEXSUBIMAGEEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLClearTexSubImageEXT, std::move(params));
      }
      if (strcmp(nameToken, "glClientActiveTexture") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCLIENTACTIVETEXTUREPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLClientActiveTexture, std::move(params));
      }
      if (strcmp(nameToken, "glClientWaitSync") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLIENTWAITSYNCPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLClientWaitSync, std::move(params));
      }
      if (strcmp(nameToken, "glClipControlEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLIPCONTROLEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLClipControlEXT, std::move(params));
      }
      if (strcmp(nameToken, "glClipPlanef") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCLIPPLANEFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLClipPlanef, std::move(params));
      }
      if (strcmp(nameToken, "glClipPlanex") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCLIPPLANEXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLClipPlanex, std::move(params));
      }
      if (strcmp(nameToken, "glColor4f") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOLOR4FPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLColor4f, std::move(params));
      }
      if (strcmp(nameToken, "glColor4ub") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOLOR4UBPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLColor4ub, std::move(params));
      }
      if (strcmp(nameToken, "glColor4x") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOLOR4XPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLColor4x, std::move(params));
      }
      if (strcmp(nameToken, "glColorMask") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOLORMASKPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLColorMask, std::move(params));
      }
      if (strcmp(nameToken, "glColorMaski") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOLORMASKIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLColorMaski, std::move(params));
      }
      if (strcmp(nameToken, "glColorMaskiEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOLORMASKIEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLColorMaskiEXT, std::move(params));
      }
      if (strcmp(nameToken, "glColorMaskiOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOLORMASKIOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLColorMaskiOES, std::move(params));
      }
      if (strcmp(nameToken, "glColorPointer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOLORPOINTERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLColorPointer, std::move(params));
      }
      if (strcmp(nameToken, "glCompileShader") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOMPILESHADERPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLCompileShader, std::move(params));
      }
      if (strcmp(nameToken, "glCompressedCopyTextureCHROMIUM") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDCOPYTEXTURECHROMIUMPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCompressedCopyTextureCHROMIUM, std::move(params));
      }
      if (strcmp(nameToken, "glCompressedTexImage2D") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXIMAGE2DPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLCompressedTexImage2D, std::move(params));
      }
      if (strcmp(nameToken, "glCompressedTexImage2DRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXIMAGE2DROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCompressedTexImage2DRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glCompressedTexImage3D") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXIMAGE3DPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLCompressedTexImage3D, std::move(params));
      }
      if (strcmp(nameToken, "glCompressedTexImage3DOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXIMAGE3DOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCompressedTexImage3DOES, std::move(params));
      }
      if (strcmp(nameToken, "glCompressedTexImage3DRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXIMAGE3DROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCompressedTexImage3DRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glCompressedTexSubImage2D") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCompressedTexSubImage2D, std::move(params));
      }
      if (strcmp(nameToken, "glCompressedTexSubImage2DRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXSUBIMAGE2DROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCompressedTexSubImage2DRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glCompressedTexSubImage3D") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCompressedTexSubImage3D, std::move(params));
      }
      if (strcmp(nameToken, "glCompressedTexSubImage3DOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXSUBIMAGE3DOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCompressedTexSubImage3DOES, std::move(params));
      }
      if (strcmp(nameToken, "glCompressedTexSubImage3DRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXSUBIMAGE3DROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCompressedTexSubImage3DRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glCopyBufferSubData") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOPYBUFFERSUBDATAPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLCopyBufferSubData, std::move(params));
      }
      if (strcmp(nameToken, "glCopyImageSubData") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOPYIMAGESUBDATAPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLCopyImageSubData, std::move(params));
      }
      if (strcmp(nameToken, "glCopyImageSubDataEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOPYIMAGESUBDATAEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLCopyImageSubDataEXT, std::move(params));
      }
      if (strcmp(nameToken, "glCopyImageSubDataOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOPYIMAGESUBDATAOESPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLCopyImageSubDataOES, std::move(params));
      }
      if (strcmp(nameToken, "glCopySubTexture3DANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOPYSUBTEXTURE3DANGLEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLCopySubTexture3DANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glCopySubTextureCHROMIUM") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOPYSUBTEXTURECHROMIUMPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLCopySubTextureCHROMIUM, std::move(params));
      }
      if (strcmp(nameToken, "glCopyTexImage2D") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOPYTEXIMAGE2DPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLCopyTexImage2D, std::move(params));
      }
      if (strcmp(nameToken, "glCopyTexSubImage2D") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOPYTEXSUBIMAGE2DPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLCopyTexSubImage2D, std::move(params));
      }
      if (strcmp(nameToken, "glCopyTexSubImage3D") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOPYTEXSUBIMAGE3DPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLCopyTexSubImage3D, std::move(params));
      }
      if (strcmp(nameToken, "glCopyTexSubImage3DOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOPYTEXSUBIMAGE3DOESPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLCopyTexSubImage3DOES, std::move(params));
      }
      if (strcmp(nameToken, "glCopyTexture3DANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOPYTEXTURE3DANGLEPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLCopyTexture3DANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glCopyTextureCHROMIUM") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOPYTEXTURECHROMIUMPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLCopyTextureCHROMIUM, std::move(params));
      }
      if (strcmp(nameToken, "glCoverageModulationCHROMIUM") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCOVERAGEMODULATIONCHROMIUMPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCoverageModulationCHROMIUM, std::move(params));
      }
      if (strcmp(nameToken, "glCreateMemoryObjectsEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCREATEMEMORYOBJECTSEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLCreateMemoryObjectsEXT, std::move(params));
      }
      if (strcmp(nameToken, "glCreateProgram") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCREATEPROGRAMPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLCreateProgram, std::move(params));
      }
      if (strcmp(nameToken, "glCreateShader") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCREATESHADERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLCreateShader, std::move(params));
      }
      if (strcmp(nameToken, "glCreateShaderProgramv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCREATESHADERPROGRAMVPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLCreateShaderProgramv, std::move(params));
      }
      if (strcmp(nameToken, "glCreateShaderProgramvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCREATESHADERPROGRAMVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCreateShaderProgramvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glCullFace") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCULLFACEPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLCullFace, std::move(params));
      }
      if (strcmp(nameToken, "glCurrentPaletteMatrixOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLCURRENTPALETTEMATRIXOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLCurrentPaletteMatrixOES, std::move(params));
      }
      if (strcmp(nameToken, "glDebugMessageCallback") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDEBUGMESSAGECALLBACKPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLDebugMessageCallback, std::move(params));
      }
      if (strcmp(nameToken, "glDebugMessageCallbackKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDEBUGMESSAGECALLBACKKHRPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDebugMessageCallbackKHR, std::move(params));
      }
      if (strcmp(nameToken, "glDebugMessageControl") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDEBUGMESSAGECONTROLPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLDebugMessageControl, std::move(params));
      }
      if (strcmp(nameToken, "glDebugMessageControlKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDEBUGMESSAGECONTROLKHRPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLDebugMessageControlKHR, std::move(params));
      }
      if (strcmp(nameToken, "glDebugMessageInsert") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDEBUGMESSAGEINSERTPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLDebugMessageInsert, std::move(params));
      }
      if (strcmp(nameToken, "glDebugMessageInsertKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDEBUGMESSAGEINSERTKHRPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLDebugMessageInsertKHR, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteBuffers") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETEBUFFERSPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLDeleteBuffers, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteFencesNV") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETEFENCESNVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLDeleteFencesNV, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteFramebuffers") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETEFRAMEBUFFERSPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLDeleteFramebuffers, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteFramebuffersOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETEFRAMEBUFFERSOESPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLDeleteFramebuffersOES, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteMemoryObjectsEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETEMEMORYOBJECTSEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLDeleteMemoryObjectsEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDeletePerfMonitorsAMD") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETEPERFMONITORSAMDPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLDeletePerfMonitorsAMD, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteProgram") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETEPROGRAMPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLDeleteProgram, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteProgramPipelines") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETEPROGRAMPIPELINESPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLDeleteProgramPipelines, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteProgramPipelinesEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETEPROGRAMPIPELINESEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDeleteProgramPipelinesEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteQueries") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETEQUERIESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLDeleteQueries, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteQueriesEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETEQUERIESEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLDeleteQueriesEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteRenderbuffers") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETERENDERBUFFERSPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLDeleteRenderbuffers, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteRenderbuffersOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETERENDERBUFFERSOESPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLDeleteRenderbuffersOES, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteSamplers") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETESAMPLERSPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLDeleteSamplers, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteSemaphoresEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETESEMAPHORESEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLDeleteSemaphoresEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteShader") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETESHADERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDeleteShader, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteSync") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETESYNCPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDeleteSync, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteTextures") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETETEXTURESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLDeleteTextures, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteTransformFeedbacks") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETETRANSFORMFEEDBACKSPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDeleteTransformFeedbacks, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteVertexArrays") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETEVERTEXARRAYSPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLDeleteVertexArrays, std::move(params));
      }
      if (strcmp(nameToken, "glDeleteVertexArraysOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDELETEVERTEXARRAYSOESPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLDeleteVertexArraysOES, std::move(params));
      }
      if (strcmp(nameToken, "glDepthFunc") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDEPTHFUNCPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDepthFunc, std::move(params));
      }
      if (strcmp(nameToken, "glDepthMask") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDEPTHMASKPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDepthMask, std::move(params));
      }
      if (strcmp(nameToken, "glDepthRangef") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDEPTHRANGEFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDepthRangef, std::move(params));
      }
      if (strcmp(nameToken, "glDepthRangex") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDEPTHRANGEXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDepthRangex, std::move(params));
      }
      if (strcmp(nameToken, "glDetachShader") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDETACHSHADERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDetachShader, std::move(params));
      }
      if (strcmp(nameToken, "glDisable") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDISABLEPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDisable, std::move(params));
      }
      if (strcmp(nameToken, "glDisableClientState") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDISABLECLIENTSTATEPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLDisableClientState, std::move(params));
      }
      if (strcmp(nameToken, "glDisableExtensionANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDISABLEEXTENSIONANGLEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLDisableExtensionANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glDisableVertexAttribArray") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDISABLEVERTEXATTRIBARRAYPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDisableVertexAttribArray, std::move(params));
      }
      if (strcmp(nameToken, "glDisablei") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDISABLEIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDisablei, std::move(params));
      }
      if (strcmp(nameToken, "glDisableiEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDISABLEIEXTPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDisableiEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDisableiOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDISABLEIOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDisableiOES, std::move(params));
      }
      if (strcmp(nameToken, "glDiscardFramebufferEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDISCARDFRAMEBUFFEREXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLDiscardFramebufferEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDispatchCompute") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDISPATCHCOMPUTEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLDispatchCompute, std::move(params));
      }
      if (strcmp(nameToken, "glDispatchComputeIndirect") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDISPATCHCOMPUTEINDIRECTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDispatchComputeIndirect, std::move(params));
      }
      if (strcmp(nameToken, "glDrawArrays") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWARRAYSPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawArrays, std::move(params));
      }
      if (strcmp(nameToken, "glDrawArraysIndirect") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWARRAYSINDIRECTPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLDrawArraysIndirect, std::move(params));
      }
      if (strcmp(nameToken, "glDrawArraysInstanced") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWARRAYSINSTANCEDPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLDrawArraysInstanced, std::move(params));
      }
      if (strcmp(nameToken, "glDrawArraysInstancedANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWARRAYSINSTANCEDANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawArraysInstancedANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glDrawArraysInstancedBaseInstanceANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEANGLEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLDrawArraysInstancedBaseInstanceANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glDrawArraysInstancedBaseInstanceEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawArraysInstancedBaseInstanceEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDrawArraysInstancedEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWARRAYSINSTANCEDEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLDrawArraysInstancedEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDrawBuffers") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWBUFFERSPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawBuffers, std::move(params));
      }
      if (strcmp(nameToken, "glDrawBuffersEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDRAWBUFFERSEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawBuffersEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDrawElements") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawElements, std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsBaseVertex") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSBASEVERTEXPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLDrawElementsBaseVertex, std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsBaseVertexEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSBASEVERTEXEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawElementsBaseVertexEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsBaseVertexOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSBASEVERTEXOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawElementsBaseVertexOES, std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsIndirect") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINDIRECTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLDrawElementsIndirect, std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsInstanced") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLDrawElementsInstanced, std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsInstancedANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawElementsInstancedANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsInstancedBaseInstanceEXT") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLDrawElementsInstancedBaseInstanceEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsInstancedBaseVertex") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawElementsInstancedBaseVertex, std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsInstancedBaseVertexBaseInstanceANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstanceANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsInstancedBaseVertexBaseInstanceEXT") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstanceEXT,
                             std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsInstancedBaseVertexEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawElementsInstancedBaseVertexEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsInstancedBaseVertexOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawElementsInstancedBaseVertexOES, std::move(params));
      }
      if (strcmp(nameToken, "glDrawElementsInstancedEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawElementsInstancedEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDrawRangeElements") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDRAWRANGEELEMENTSPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawRangeElements, std::move(params));
      }
      if (strcmp(nameToken, "glDrawRangeElementsBaseVertex") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawRangeElementsBaseVertex, std::move(params));
      }
      if (strcmp(nameToken, "glDrawRangeElementsBaseVertexEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawRangeElementsBaseVertexEXT, std::move(params));
      }
      if (strcmp(nameToken, "glDrawRangeElementsBaseVertexOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWRANGEELEMENTSBASEVERTEXOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawRangeElementsBaseVertexOES, std::move(params));
      }
      if (strcmp(nameToken, "glDrawTexfOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWTEXFOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawTexfOES, std::move(params));
      }
      if (strcmp(nameToken, "glDrawTexfvOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWTEXFVOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawTexfvOES, std::move(params));
      }
      if (strcmp(nameToken, "glDrawTexiOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWTEXIOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawTexiOES, std::move(params));
      }
      if (strcmp(nameToken, "glDrawTexivOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWTEXIVOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawTexivOES, std::move(params));
      }
      if (strcmp(nameToken, "glDrawTexsOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWTEXSOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawTexsOES, std::move(params));
      }
      if (strcmp(nameToken, "glDrawTexsvOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWTEXSVOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawTexsvOES, std::move(params));
      }
      if (strcmp(nameToken, "glDrawTexxOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWTEXXOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawTexxOES, std::move(params));
      }
      if (strcmp(nameToken, "glDrawTexxvOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLDRAWTEXXVOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLDrawTexxvOES, std::move(params));
      }
      if (strcmp(nameToken, "glEGLImageTargetRenderbufferStorageOES") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLEGLImageTargetRenderbufferStorageOES, std::move(params));
      }
      if (strcmp(nameToken, "glEGLImageTargetTexStorageEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLEGLImageTargetTexStorageEXT, std::move(params));
      }
      if (strcmp(nameToken, "glEGLImageTargetTexture2DOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLEGLIMAGETARGETTEXTURE2DOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLEGLImageTargetTexture2DOES, std::move(params));
      }
      if (strcmp(nameToken, "glEGLImageTargetTextureStorageEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLEGLImageTargetTextureStorageEXT, std::move(params));
      }
      if (strcmp(nameToken, "glEnable") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLENABLEPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLEnable, std::move(params));
      }
      if (strcmp(nameToken, "glEnableClientState") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLENABLECLIENTSTATEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLEnableClientState, std::move(params));
      }
      if (strcmp(nameToken, "glEnableVertexAttribArray") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLENABLEVERTEXATTRIBARRAYPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLEnableVertexAttribArray, std::move(params));
      }
      if (strcmp(nameToken, "glEnablei") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLENABLEIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLEnablei, std::move(params));
      }
      if (strcmp(nameToken, "glEnableiEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLENABLEIEXTPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLEnableiEXT, std::move(params));
      }
      if (strcmp(nameToken, "glEnableiOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLENABLEIOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLEnableiOES, std::move(params));
      }
      if (strcmp(nameToken, "glEndPerfMonitorAMD") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLENDPERFMONITORAMDPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLEndPerfMonitorAMD, std::move(params));
      }
      if (strcmp(nameToken, "glEndPixelLocalStorageANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLENDPIXELLOCALSTORAGEANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLEndPixelLocalStorageANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glEndQuery") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLENDQUERYPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLEndQuery, std::move(params));
      }
      if (strcmp(nameToken, "glEndQueryEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLENDQUERYEXTPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLEndQueryEXT, std::move(params));
      }
      if (strcmp(nameToken, "glEndTilingQCOM") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLENDTILINGQCOMPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLEndTilingQCOM, std::move(params));
      }
      if (strcmp(nameToken, "glEndTransformFeedback") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLENDTRANSFORMFEEDBACKPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLEndTransformFeedback, std::move(params));
      }
      if (strcmp(nameToken, "glFenceSync") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFENCESYNCPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLFenceSync, std::move(params));
      }
      if (strcmp(nameToken, "glFinish") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFINISHPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLFinish, std::move(params));
      }
      if (strcmp(nameToken, "glFinishFenceNV") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLFINISHFENCENVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLFinishFenceNV, std::move(params));
      }
      if (strcmp(nameToken, "glFlush") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFLUSHPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLFlush, std::move(params));
      }
      if (strcmp(nameToken, "glFlushMappedBufferRange") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFLUSHMAPPEDBUFFERRANGEPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLFlushMappedBufferRange, std::move(params));
      }
      if (strcmp(nameToken, "glFlushMappedBufferRangeEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLFlushMappedBufferRangeEXT, std::move(params));
      }
      if (strcmp(nameToken, "glFogf") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFOGFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLFogf, std::move(params));
      }
      if (strcmp(nameToken, "glFogfv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFOGFVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLFogfv, std::move(params));
      }
      if (strcmp(nameToken, "glFogx") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFOGXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLFogx, std::move(params));
      }
      if (strcmp(nameToken, "glFogxv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFOGXVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLFogxv, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferFetchBarrierEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferFetchBarrierEXT, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferFoveationConfigQCOM") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferFoveationConfigQCOM, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferFoveationParametersQCOM") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferFoveationParametersQCOM, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferMemorylessPixelLocalStorageANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLFRAMEBUFFERMEMORYLESSPIXELLOCALSTORAGEANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferMemorylessPixelLocalStorageANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferParameteri") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERPARAMETERIPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLFramebufferParameteri, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferParameteriMESA") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERPARAMETERIMESAPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferParameteriMESA, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferPixelLocalClearValuefvANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEFVANGLEPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLFramebufferPixelLocalClearValuefvANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferPixelLocalClearValueivANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEIVANGLEPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLFramebufferPixelLocalClearValueivANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferPixelLocalClearValueuivANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEUIVANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferPixelLocalClearValueuivANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferPixelLocalStorageInterruptANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALSTORAGEINTERRUPTANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferPixelLocalStorageInterruptANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferPixelLocalStorageRestoreANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALSTORAGERESTOREANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferPixelLocalStorageRestoreANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferRenderbuffer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERRENDERBUFFERPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferRenderbuffer, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferRenderbufferOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERRENDERBUFFEROESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferRenderbufferOES, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferTexture") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLFramebufferTexture, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferTexture2D") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURE2DPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLFramebufferTexture2D, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferTexture2DMultisampleEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferTexture2DMultisampleEXT, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferTexture2DOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURE2DOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferTexture2DOES, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferTexture3DOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURE3DOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferTexture3DOES, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferTextureEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREEXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLFramebufferTextureEXT, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferTextureLayer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURELAYERPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferTextureLayer, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferTextureMultiviewOVR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferTextureMultiviewOVR, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferTextureOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREOESPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLFramebufferTextureOES, std::move(params));
      }
      if (strcmp(nameToken, "glFramebufferTexturePixelLocalStorageANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREPIXELLOCALSTORAGEANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLFramebufferTexturePixelLocalStorageANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glFrontFace") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRONTFACEPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLFrontFace, std::move(params));
      }
      if (strcmp(nameToken, "glFrustumf") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRUSTUMFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLFrustumf, std::move(params));
      }
      if (strcmp(nameToken, "glFrustumx") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLFRUSTUMXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLFrustumx, std::move(params));
      }
      if (strcmp(nameToken, "glGenBuffers") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGENBUFFERSPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGenBuffers, std::move(params));
      }
      if (strcmp(nameToken, "glGenFencesNV") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGENFENCESNVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGenFencesNV, std::move(params));
      }
      if (strcmp(nameToken, "glGenFramebuffers") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENFRAMEBUFFERSPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGenFramebuffers, std::move(params));
      }
      if (strcmp(nameToken, "glGenFramebuffersOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGENFRAMEBUFFERSOESPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLGenFramebuffersOES, std::move(params));
      }
      if (strcmp(nameToken, "glGenPerfMonitorsAMD") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGENPERFMONITORSAMDPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLGenPerfMonitorsAMD, std::move(params));
      }
      if (strcmp(nameToken, "glGenProgramPipelines") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGENPROGRAMPIPELINESPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLGenProgramPipelines, std::move(params));
      }
      if (strcmp(nameToken, "glGenProgramPipelinesEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGENPROGRAMPIPELINESEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGenProgramPipelinesEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGenQueries") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGENQUERIESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGenQueries, std::move(params));
      }
      if (strcmp(nameToken, "glGenQueriesEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENQUERIESEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGenQueriesEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGenRenderbuffers") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENRENDERBUFFERSPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGenRenderbuffers, std::move(params));
      }
      if (strcmp(nameToken, "glGenRenderbuffersOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGENRENDERBUFFERSOESPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLGenRenderbuffersOES, std::move(params));
      }
      if (strcmp(nameToken, "glGenSamplers") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGENSAMPLERSPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGenSamplers, std::move(params));
      }
      if (strcmp(nameToken, "glGenSemaphoresEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENSEMAPHORESEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGenSemaphoresEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGenTextures") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGENTEXTURESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGenTextures, std::move(params));
      }
      if (strcmp(nameToken, "glGenTransformFeedbacks") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGENTRANSFORMFEEDBACKSPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLGenTransformFeedbacks, std::move(params));
      }
      if (strcmp(nameToken, "glGenVertexArrays") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENVERTEXARRAYSPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGenVertexArrays, std::move(params));
      }
      if (strcmp(nameToken, "glGenVertexArraysOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGENVERTEXARRAYSOESPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLGenVertexArraysOES, std::move(params));
      }
      if (strcmp(nameToken, "glGenerateMipmap") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENERATEMIPMAPPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGenerateMipmap, std::move(params));
      }
      if (strcmp(nameToken, "glGenerateMipmapOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENERATEMIPMAPOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGenerateMipmapOES, std::move(params));
      }
      if (strcmp(nameToken, "glGetActiveAttrib") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETACTIVEATTRIBPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetActiveAttrib, std::move(params));
      }
      if (strcmp(nameToken, "glGetActiveUniform") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetActiveUniform, std::move(params));
      }
      if (strcmp(nameToken, "glGetActiveUniformBlockName") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetActiveUniformBlockName, std::move(params));
      }
      if (strcmp(nameToken, "glGetActiveUniformBlockiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMBLOCKIVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetActiveUniformBlockiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetActiveUniformBlockivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMBLOCKIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetActiveUniformBlockivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetActiveUniformsiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMSIVPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLGetActiveUniformsiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetAttachedShaders") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETATTACHEDSHADERSPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLGetAttachedShaders, std::move(params));
      }
      if (strcmp(nameToken, "glGetAttribLocation") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETATTRIBLOCATIONPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetAttribLocation, std::move(params));
      }
      if (strcmp(nameToken, "glGetBooleani_v") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETBOOLEANI_VPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetBooleani_v, std::move(params));
      }
      if (strcmp(nameToken, "glGetBooleani_vRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETBOOLEANI_VROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetBooleani_vRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetBooleanv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETBOOLEANVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetBooleanv, std::move(params));
      }
      if (strcmp(nameToken, "glGetBooleanvRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETBOOLEANVROBUSTANGLEPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetBooleanvRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetBufferParameteri64v") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETBUFFERPARAMETERI64VPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetBufferParameteri64v, std::move(params));
      }
      if (strcmp(nameToken, "glGetBufferParameteri64vRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETBUFFERPARAMETERI64VROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetBufferParameteri64vRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetBufferParameteriv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETBUFFERPARAMETERIVPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLGetBufferParameteriv, std::move(params));
      }
      if (strcmp(nameToken, "glGetBufferParameterivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETBUFFERPARAMETERIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetBufferParameterivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetBufferPointerv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETBUFFERPOINTERVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetBufferPointerv, std::move(params));
      }
      if (strcmp(nameToken, "glGetBufferPointervOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETBUFFERPOINTERVOESPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLGetBufferPointervOES, std::move(params));
      }
      if (strcmp(nameToken, "glGetBufferPointervRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETBUFFERPOINTERVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetBufferPointervRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetClipPlanef") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETCLIPPLANEFPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetClipPlanef, std::move(params));
      }
      if (strcmp(nameToken, "glGetClipPlanex") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETCLIPPLANEXPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetClipPlanex, std::move(params));
      }
      if (strcmp(nameToken, "glGetCompressedTexImageANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETCOMPRESSEDTEXIMAGEANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetCompressedTexImageANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetDebugMessageLog") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETDEBUGMESSAGELOGPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLGetDebugMessageLog, std::move(params));
      }
      if (strcmp(nameToken, "glGetDebugMessageLogKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETDEBUGMESSAGELOGKHRPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLGetDebugMessageLogKHR, std::move(params));
      }
      if (strcmp(nameToken, "glGetError") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETERRORPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetError, std::move(params));
      }
      if (strcmp(nameToken, "glGetFenceivNV") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETFENCEIVNVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetFenceivNV, std::move(params));
      }
      if (strcmp(nameToken, "glGetFixedv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETFIXEDVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetFixedv, std::move(params));
      }
      if (strcmp(nameToken, "glGetFloatv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETFLOATVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetFloatv, std::move(params));
      }
      if (strcmp(nameToken, "glGetFloatvRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETFLOATVROBUSTANGLEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLGetFloatvRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetFragDataIndexEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETFRAGDATAINDEXEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLGetFragDataIndexEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetFragDataLocation") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETFRAGDATALOCATIONPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLGetFragDataLocation, std::move(params));
      }
      if (strcmp(nameToken, "glGetFramebufferAttachmentParameteriv") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLGetFramebufferAttachmentParameteriv, std::move(params));
      }
      if (strcmp(nameToken, "glGetFramebufferAttachmentParameterivOES") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetFramebufferAttachmentParameterivOES, std::move(params));
      }
      if (strcmp(nameToken, "glGetFramebufferAttachmentParameterivRobustANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVROBUSTANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetFramebufferAttachmentParameterivRobustANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glGetFramebufferParameteriv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETFRAMEBUFFERPARAMETERIVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetFramebufferParameteriv, std::move(params));
      }
      if (strcmp(nameToken, "glGetFramebufferParameterivMESA") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETFRAMEBUFFERPARAMETERIVMESAPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetFramebufferParameterivMESA, std::move(params));
      }
      if (strcmp(nameToken, "glGetFramebufferParameterivRobustANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLGETFRAMEBUFFERPARAMETERIVROBUSTANGLEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLGetFramebufferParameterivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetFramebufferPixelLocalStorageParameterfvANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetFramebufferPixelLocalStorageParameterfvANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glGetFramebufferPixelLocalStorageParameterfvRobustANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<
              PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVROBUSTANGLEPROC>::type>(paramTokens,
                                                                                     strings);
          return CallCapture(EntryPoint::GLGetFramebufferPixelLocalStorageParameterfvRobustANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glGetFramebufferPixelLocalStorageParameterivANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetFramebufferPixelLocalStorageParameterivANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glGetFramebufferPixelLocalStorageParameterivRobustANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<
              PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVROBUSTANGLEPROC>::type>(paramTokens,
                                                                                     strings);
          return CallCapture(EntryPoint::GLGetFramebufferPixelLocalStorageParameterivRobustANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glGetGraphicsResetStatus") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETGRAPHICSRESETSTATUSPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetGraphicsResetStatus, std::move(params));
      }
      if (strcmp(nameToken, "glGetGraphicsResetStatusEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETGRAPHICSRESETSTATUSEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetGraphicsResetStatusEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetGraphicsResetStatusKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETGRAPHICSRESETSTATUSKHRPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetGraphicsResetStatusKHR, std::move(params));
      }
      if (strcmp(nameToken, "glGetInteger64i_v") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETINTEGER64I_VPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetInteger64i_v, std::move(params));
      }
      if (strcmp(nameToken, "glGetInteger64i_vRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETINTEGER64I_VROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetInteger64i_vRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetInteger64v") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETINTEGER64VPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetInteger64v, std::move(params));
      }
      if (strcmp(nameToken, "glGetInteger64vEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETINTEGER64VEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetInteger64vEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetInteger64vRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETINTEGER64VROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetInteger64vRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetIntegeri_v") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETINTEGERI_VPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetIntegeri_v, std::move(params));
      }
      if (strcmp(nameToken, "glGetIntegeri_vRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETINTEGERI_VROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetIntegeri_vRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetIntegerv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETINTEGERVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetIntegerv, std::move(params));
      }
      if (strcmp(nameToken, "glGetIntegervRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETINTEGERVROBUSTANGLEPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetIntegervRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetInternalformativ") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETINTERNALFORMATIVPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLGetInternalformativ, std::move(params));
      }
      if (strcmp(nameToken, "glGetInternalformativRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETINTERNALFORMATIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetInternalformativRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetLightfv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETLIGHTFVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetLightfv, std::move(params));
      }
      if (strcmp(nameToken, "glGetLightxv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETLIGHTXVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetLightxv, std::move(params));
      }
      if (strcmp(nameToken, "glGetMaterialfv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETMATERIALFVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetMaterialfv, std::move(params));
      }
      if (strcmp(nameToken, "glGetMaterialxv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETMATERIALXVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetMaterialxv, std::move(params));
      }
      if (strcmp(nameToken, "glGetMemoryObjectParameterivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetMemoryObjectParameterivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetMultisamplefv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETMULTISAMPLEFVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetMultisamplefv, std::move(params));
      }
      if (strcmp(nameToken, "glGetMultisamplefvANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETMULTISAMPLEFVANGLEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLGetMultisamplefvANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetMultisamplefvRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETMULTISAMPLEFVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetMultisamplefvRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetObjectLabel") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETOBJECTLABELPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetObjectLabel, std::move(params));
      }
      if (strcmp(nameToken, "glGetObjectLabelEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETOBJECTLABELEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetObjectLabelEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetObjectLabelKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETOBJECTLABELKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetObjectLabelKHR, std::move(params));
      }
      if (strcmp(nameToken, "glGetObjectPtrLabel") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETOBJECTPTRLABELPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetObjectPtrLabel, std::move(params));
      }
      if (strcmp(nameToken, "glGetObjectPtrLabelKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETOBJECTPTRLABELKHRPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLGetObjectPtrLabelKHR, std::move(params));
      }
      if (strcmp(nameToken, "glGetPerfMonitorCounterDataAMD") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORCOUNTERDATAAMDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetPerfMonitorCounterDataAMD, std::move(params));
      }
      if (strcmp(nameToken, "glGetPerfMonitorCounterInfoAMD") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORCOUNTERINFOAMDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetPerfMonitorCounterInfoAMD, std::move(params));
      }
      if (strcmp(nameToken, "glGetPerfMonitorCounterStringAMD") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetPerfMonitorCounterStringAMD, std::move(params));
      }
      if (strcmp(nameToken, "glGetPerfMonitorCountersAMD") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORCOUNTERSAMDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetPerfMonitorCountersAMD, std::move(params));
      }
      if (strcmp(nameToken, "glGetPerfMonitorGroupStringAMD") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORGROUPSTRINGAMDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetPerfMonitorGroupStringAMD, std::move(params));
      }
      if (strcmp(nameToken, "glGetPerfMonitorGroupsAMD") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORGROUPSAMDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetPerfMonitorGroupsAMD, std::move(params));
      }
      if (strcmp(nameToken, "glGetPointerv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPOINTERVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetPointerv, std::move(params));
      }
      if (strcmp(nameToken, "glGetPointervANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETPOINTERVANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetPointervANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetPointervKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETPOINTERVKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetPointervKHR, std::move(params));
      }
      if (strcmp(nameToken, "glGetPointervRobustANGLERobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPOINTERVROBUSTANGLEROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetPointervRobustANGLERobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramBinary") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETPROGRAMBINARYPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetProgramBinary, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramBinaryOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMBINARYOESPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLGetProgramBinaryOES, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramInfoLog") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETPROGRAMINFOLOGPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetProgramInfoLog, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramInterfaceiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMINTERFACEIVPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLGetProgramInterfaceiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramInterfaceivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMINTERFACEIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetProgramInterfaceivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramPipelineInfoLog") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMPIPELINEINFOLOGPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetProgramPipelineInfoLog, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramPipelineInfoLogEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMPIPELINEINFOLOGEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetProgramPipelineInfoLogEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramPipelineiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMPIPELINEIVPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLGetProgramPipelineiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramPipelineivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMPIPELINEIVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetProgramPipelineivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramResourceIndex") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCEINDEXPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetProgramResourceIndex, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramResourceLocation") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCELOCATIONPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetProgramResourceLocation, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramResourceLocationIndexEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetProgramResourceLocationIndexEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramResourceName") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCENAMEPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetProgramResourceName, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramResourceiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCEIVPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLGetProgramResourceiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMIVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetProgramiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetProgramivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETPROGRAMIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetProgramivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetQueryObjecti64vEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTI64VEXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLGetQueryObjecti64vEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetQueryObjecti64vRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTI64VROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetQueryObjecti64vRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetQueryObjectivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTIVEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLGetQueryObjectivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetQueryObjectivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetQueryObjectivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetQueryObjectui64vEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUI64VEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetQueryObjectui64vEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetQueryObjectui64vRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUI64VROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetQueryObjectui64vRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetQueryObjectuiv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUIVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetQueryObjectuiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetQueryObjectuivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUIVEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLGetQueryObjectuivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetQueryObjectuivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetQueryObjectuivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetQueryiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETQUERYIVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetQueryiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetQueryivEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETQUERYIVEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetQueryivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetQueryivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETQUERYIVROBUSTANGLEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLGetQueryivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetRenderbufferImageANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETRENDERBUFFERIMAGEANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetRenderbufferImageANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetRenderbufferParameteriv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETRENDERBUFFERPARAMETERIVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetRenderbufferParameteriv, std::move(params));
      }
      if (strcmp(nameToken, "glGetRenderbufferParameterivOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETRENDERBUFFERPARAMETERIVOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetRenderbufferParameterivOES, std::move(params));
      }
      if (strcmp(nameToken, "glGetRenderbufferParameterivRobustANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLGETRENDERBUFFERPARAMETERIVROBUSTANGLEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLGetRenderbufferParameterivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetSamplerParameterIiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIIVPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetSamplerParameterIiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetSamplerParameterIivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIIVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetSamplerParameterIivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetSamplerParameterIivOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIIVOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetSamplerParameterIivOES, std::move(params));
      }
      if (strcmp(nameToken, "glGetSamplerParameterIivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetSamplerParameterIivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetSamplerParameterIuiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIUIVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetSamplerParameterIuiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetSamplerParameterIuivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIUIVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetSamplerParameterIuivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetSamplerParameterIuivOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIUIVOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetSamplerParameterIuivOES, std::move(params));
      }
      if (strcmp(nameToken, "glGetSamplerParameterIuivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIUIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetSamplerParameterIuivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetSamplerParameterfv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERFVPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLGetSamplerParameterfv, std::move(params));
      }
      if (strcmp(nameToken, "glGetSamplerParameterfvRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERFVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetSamplerParameterfvRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetSamplerParameteriv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIVPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLGetSamplerParameteriv, std::move(params));
      }
      if (strcmp(nameToken, "glGetSamplerParameterivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetSamplerParameterivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetSemaphoreParameterui64vEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetSemaphoreParameterui64vEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetShaderInfoLog") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETSHADERINFOLOGPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetShaderInfoLog, std::move(params));
      }
      if (strcmp(nameToken, "glGetShaderPrecisionFormat") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSHADERPRECISIONFORMATPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetShaderPrecisionFormat, std::move(params));
      }
      if (strcmp(nameToken, "glGetShaderSource") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETSHADERSOURCEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetShaderSource, std::move(params));
      }
      if (strcmp(nameToken, "glGetShaderiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSHADERIVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetShaderiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetShaderivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSHADERIVROBUSTANGLEPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetShaderivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetString") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSTRINGPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetString, std::move(params));
      }
      if (strcmp(nameToken, "glGetStringi") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSTRINGIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetStringi, std::move(params));
      }
      if (strcmp(nameToken, "glGetSynciv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETSYNCIVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetSynciv, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexEnvfv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXENVFVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexEnvfv, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexEnviv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXENVIVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexEnviv, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexEnvxv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXENVXVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexEnvxv, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexGenfvOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXGENFVOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexGenfvOES, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexGenivOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXGENIVOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexGenivOES, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexGenxvOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXGENXVOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexGenxvOES, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexImageANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXIMAGEANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexImageANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexLevelParameterfv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERFVPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetTexLevelParameterfv, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexLevelParameterfvANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERFVANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexLevelParameterfvANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexLevelParameterfvRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERFVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexLevelParameterfvRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexLevelParameteriv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERIVPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetTexLevelParameteriv, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexLevelParameterivANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERIVANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexLevelParameterivANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexLevelParameterivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexLevelParameterivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameterIiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIIVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLGetTexParameterIiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameterIivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIIVEXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLGetTexParameterIivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameterIivOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIIVOESPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLGetTexParameterIivOES, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameterIivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexParameterIivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameterIuiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIUIVPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLGetTexParameterIuiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameterIuivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIUIVEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetTexParameterIuivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameterIuivOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIUIVOESPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLGetTexParameterIuivOES, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameterIuivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIUIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexParameterIuivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameterfv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERFVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexParameterfv, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameterfvRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERFVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexParameterfvRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameteriv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexParameteriv, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameterivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexParameterivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetTexParameterxv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERXVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTexParameterxv, std::move(params));
      }
      if (strcmp(nameToken, "glGetTransformFeedbackVarying") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTRANSFORMFEEDBACKVARYINGPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTransformFeedbackVarying, std::move(params));
      }
      if (strcmp(nameToken, "glGetTranslatedShaderSourceANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetTranslatedShaderSourceANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetUniformBlockIndex") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETUNIFORMBLOCKINDEXPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLGetUniformBlockIndex, std::move(params));
      }
      if (strcmp(nameToken, "glGetUniformIndices") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETUNIFORMINDICESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetUniformIndices, std::move(params));
      }
      if (strcmp(nameToken, "glGetUniformLocation") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETUNIFORMLOCATIONPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLGetUniformLocation, std::move(params));
      }
      if (strcmp(nameToken, "glGetUniformfv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETUNIFORMFVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetUniformfv, std::move(params));
      }
      if (strcmp(nameToken, "glGetUniformfvRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETUNIFORMFVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetUniformfvRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetUniformiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETUNIFORMIVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLGetUniformiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetUniformivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETUNIFORMIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetUniformivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetUniformuiv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETUNIFORMUIVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetUniformuiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetUniformuivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETUNIFORMUIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetUniformuivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetUnsignedBytei_vEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETUNSIGNEDBYTEI_VEXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLGetUnsignedBytei_vEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetUnsignedBytevEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETUNSIGNEDBYTEVEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLGetUnsignedBytevEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetVertexAttribIiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIIVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLGetVertexAttribIiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetVertexAttribIivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetVertexAttribIivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetVertexAttribIuiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIUIVPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLGetVertexAttribIuiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetVertexAttribIuivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIUIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetVertexAttribIuivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetVertexAttribPointerv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBPOINTERVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetVertexAttribPointerv, std::move(params));
      }
      if (strcmp(nameToken, "glGetVertexAttribPointervRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBPOINTERVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetVertexAttribPointervRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetVertexAttribfv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBFVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetVertexAttribfv, std::move(params));
      }
      if (strcmp(nameToken, "glGetVertexAttribfvRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBFVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetVertexAttribfvRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetVertexAttribiv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetVertexAttribiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetVertexAttribivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetVertexAttribivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetnUniformfv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMFVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetnUniformfv, std::move(params));
      }
      if (strcmp(nameToken, "glGetnUniformfvEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMFVEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetnUniformfvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetnUniformfvKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMFVKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetnUniformfvKHR, std::move(params));
      }
      if (strcmp(nameToken, "glGetnUniformfvRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMFVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetnUniformfvRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetnUniformiv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMIVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetnUniformiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetnUniformivEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMIVEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetnUniformivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glGetnUniformivKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMIVKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetnUniformivKHR, std::move(params));
      }
      if (strcmp(nameToken, "glGetnUniformivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetnUniformivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glGetnUniformuiv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMUIVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetnUniformuiv, std::move(params));
      }
      if (strcmp(nameToken, "glGetnUniformuivKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMUIVKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLGetnUniformuivKHR, std::move(params));
      }
      if (strcmp(nameToken, "glGetnUniformuivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMUIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLGetnUniformuivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glHint") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLHINTPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLHint, std::move(params));
      }
      if (strcmp(nameToken, "glImportMemoryFdEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLIMPORTMEMORYFDEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLImportMemoryFdEXT, std::move(params));
      }
      if (strcmp(nameToken, "glImportMemoryZirconHandleANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLIMPORTMEMORYZIRCONHANDLEANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLImportMemoryZirconHandleANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glImportSemaphoreFdEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLIMPORTSEMAPHOREFDEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLImportSemaphoreFdEXT, std::move(params));
      }
      if (strcmp(nameToken, "glImportSemaphoreZirconHandleANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLIMPORTSEMAPHOREZIRCONHANDLEANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLImportSemaphoreZirconHandleANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glInsertEventMarkerEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLINSERTEVENTMARKEREXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLInsertEventMarkerEXT, std::move(params));
      }
      if (strcmp(nameToken, "glInvalidateFramebuffer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLINVALIDATEFRAMEBUFFERPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLInvalidateFramebuffer, std::move(params));
      }
      if (strcmp(nameToken, "glInvalidateSubFramebuffer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLINVALIDATESUBFRAMEBUFFERPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLInvalidateSubFramebuffer, std::move(params));
      }
      if (strcmp(nameToken, "glInvalidateTextureANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLINVALIDATETEXTUREANGLEPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLInvalidateTextureANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glIsBuffer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISBUFFERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLIsBuffer, std::move(params));
      }
      if (strcmp(nameToken, "glIsEnabled") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISENABLEDPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLIsEnabled, std::move(params));
      }
      if (strcmp(nameToken, "glIsEnabledi") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISENABLEDIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLIsEnabledi, std::move(params));
      }
      if (strcmp(nameToken, "glIsEnablediEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISENABLEDIEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLIsEnablediEXT, std::move(params));
      }
      if (strcmp(nameToken, "glIsEnablediOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISENABLEDIOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLIsEnablediOES, std::move(params));
      }
      if (strcmp(nameToken, "glIsFenceNV") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISFENCENVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLIsFenceNV, std::move(params));
      }
      if (strcmp(nameToken, "glIsFramebuffer") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISFRAMEBUFFERPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLIsFramebuffer, std::move(params));
      }
      if (strcmp(nameToken, "glIsFramebufferOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISFRAMEBUFFEROESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLIsFramebufferOES, std::move(params));
      }
      if (strcmp(nameToken, "glIsMemoryObjectEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISMEMORYOBJECTEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLIsMemoryObjectEXT, std::move(params));
      }
      if (strcmp(nameToken, "glIsProgram") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISPROGRAMPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLIsProgram, std::move(params));
      }
      if (strcmp(nameToken, "glIsProgramPipeline") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISPROGRAMPIPELINEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLIsProgramPipeline, std::move(params));
      }
      if (strcmp(nameToken, "glIsProgramPipelineEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISPROGRAMPIPELINEEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLIsProgramPipelineEXT, std::move(params));
      }
      if (strcmp(nameToken, "glIsQuery") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISQUERYPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLIsQuery, std::move(params));
      }
      if (strcmp(nameToken, "glIsQueryEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISQUERYEXTPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLIsQueryEXT, std::move(params));
      }
      if (strcmp(nameToken, "glIsRenderbuffer") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISRENDERBUFFERPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLIsRenderbuffer, std::move(params));
      }
      if (strcmp(nameToken, "glIsRenderbufferOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISRENDERBUFFEROESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLIsRenderbufferOES, std::move(params));
      }
      if (strcmp(nameToken, "glIsSampler") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISSAMPLERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLIsSampler, std::move(params));
      }
      if (strcmp(nameToken, "glIsSemaphoreEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISSEMAPHOREEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLIsSemaphoreEXT, std::move(params));
      }
      if (strcmp(nameToken, "glIsShader") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISSHADERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLIsShader, std::move(params));
      }
      if (strcmp(nameToken, "glIsSync") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISSYNCPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLIsSync, std::move(params));
      }
      if (strcmp(nameToken, "glIsTexture") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISTEXTUREPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLIsTexture, std::move(params));
      }
      if (strcmp(nameToken, "glIsTransformFeedback") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLISTRANSFORMFEEDBACKPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLIsTransformFeedback, std::move(params));
      }
      if (strcmp(nameToken, "glIsVertexArray") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISVERTEXARRAYPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLIsVertexArray, std::move(params));
      }
      if (strcmp(nameToken, "glIsVertexArrayOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISVERTEXARRAYOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLIsVertexArrayOES, std::move(params));
      }
      if (strcmp(nameToken, "glLabelObjectEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLLABELOBJECTEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLLabelObjectEXT, std::move(params));
      }
      if (strcmp(nameToken, "glLightModelf") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLIGHTMODELFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLightModelf, std::move(params));
      }
      if (strcmp(nameToken, "glLightModelfv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLIGHTMODELFVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLightModelfv, std::move(params));
      }
      if (strcmp(nameToken, "glLightModelx") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLIGHTMODELXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLightModelx, std::move(params));
      }
      if (strcmp(nameToken, "glLightModelxv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLIGHTMODELXVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLightModelxv, std::move(params));
      }
      if (strcmp(nameToken, "glLightf") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLIGHTFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLightf, std::move(params));
      }
      if (strcmp(nameToken, "glLightfv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLIGHTFVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLightfv, std::move(params));
      }
      if (strcmp(nameToken, "glLightx") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLIGHTXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLightx, std::move(params));
      }
      if (strcmp(nameToken, "glLightxv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLIGHTXVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLightxv, std::move(params));
      }
      if (strcmp(nameToken, "glLineWidth") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLINEWIDTHPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLineWidth, std::move(params));
      }
      if (strcmp(nameToken, "glLineWidthx") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLINEWIDTHXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLineWidthx, std::move(params));
      }
      if (strcmp(nameToken, "glLinkProgram") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLINKPROGRAMPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLinkProgram, std::move(params));
      }
      if (strcmp(nameToken, "glLoadIdentity") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLOADIDENTITYPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLoadIdentity, std::move(params));
      }
      if (strcmp(nameToken, "glLoadMatrixf") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLOADMATRIXFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLoadMatrixf, std::move(params));
      }
      if (strcmp(nameToken, "glLoadMatrixx") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLOADMATRIXXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLoadMatrixx, std::move(params));
      }
      if (strcmp(nameToken, "glLoadPaletteFromModelViewMatrixOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLOADPALETTEFROMMODELVIEWMATRIXOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLLoadPaletteFromModelViewMatrixOES, std::move(params));
      }
      if (strcmp(nameToken, "glLogicOp") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLOGICOPPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLogicOp, std::move(params));
      }
      if (strcmp(nameToken, "glLogicOpANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLOGICOPANGLEPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLLogicOpANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glLoseContextCHROMIUM") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLLOSECONTEXTCHROMIUMPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLLoseContextCHROMIUM, std::move(params));
      }
      if (strcmp(nameToken, "glMapBufferOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMAPBUFFEROESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLMapBufferOES, std::move(params));
      }
      if (strcmp(nameToken, "glMapBufferRange") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMAPBUFFERRANGEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLMapBufferRange, std::move(params));
      }
      if (strcmp(nameToken, "glMapBufferRangeEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMAPBUFFERRANGEEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLMapBufferRangeEXT, std::move(params));
      }
      if (strcmp(nameToken, "glMaterialf") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMATERIALFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLMaterialf, std::move(params));
      }
      if (strcmp(nameToken, "glMaterialfv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMATERIALFVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLMaterialfv, std::move(params));
      }
      if (strcmp(nameToken, "glMaterialx") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMATERIALXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLMaterialx, std::move(params));
      }
      if (strcmp(nameToken, "glMaterialxv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMATERIALXVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLMaterialxv, std::move(params));
      }
      if (strcmp(nameToken, "glMatrixIndexPointerOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMATRIXINDEXPOINTEROESPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLMatrixIndexPointerOES, std::move(params));
      }
      if (strcmp(nameToken, "glMatrixMode") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMATRIXMODEPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLMatrixMode, std::move(params));
      }
      if (strcmp(nameToken, "glMaxShaderCompilerThreadsKHR") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMAXSHADERCOMPILERTHREADSKHRPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLMaxShaderCompilerThreadsKHR, std::move(params));
      }
      if (strcmp(nameToken, "glMemoryBarrier") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMEMORYBARRIERPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLMemoryBarrier, std::move(params));
      }
      if (strcmp(nameToken, "glMemoryBarrierByRegion") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMEMORYBARRIERBYREGIONPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLMemoryBarrierByRegion, std::move(params));
      }
      if (strcmp(nameToken, "glMemoryObjectParameterivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMEMORYOBJECTPARAMETERIVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLMemoryObjectParameterivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glMinSampleShading") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMINSAMPLESHADINGPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLMinSampleShading, std::move(params));
      }
      if (strcmp(nameToken, "glMinSampleShadingOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMINSAMPLESHADINGOESPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLMinSampleShadingOES, std::move(params));
      }
      if (strcmp(nameToken, "glMultMatrixf") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMULTMATRIXFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLMultMatrixf, std::move(params));
      }
      if (strcmp(nameToken, "glMultMatrixx") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMULTMATRIXXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLMultMatrixx, std::move(params));
      }
      if (strcmp(nameToken, "glMultiDrawArraysANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMULTIDRAWARRAYSANGLEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLMultiDrawArraysANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glMultiDrawArraysIndirectEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMULTIDRAWARRAYSINDIRECTEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLMultiDrawArraysIndirectEXT, std::move(params));
      }
      if (strcmp(nameToken, "glMultiDrawArraysInstancedANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMULTIDRAWARRAYSINSTANCEDANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLMultiDrawArraysInstancedANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glMultiDrawArraysInstancedBaseInstanceANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLMULTIDRAWARRAYSINSTANCEDBASEINSTANCEANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLMultiDrawArraysInstancedBaseInstanceANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glMultiDrawElementsANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMULTIDRAWELEMENTSANGLEPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLMultiDrawElementsANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glMultiDrawElementsBaseVertexEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLMultiDrawElementsBaseVertexEXT, std::move(params));
      }
      if (strcmp(nameToken, "glMultiDrawElementsIndirectEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMULTIDRAWELEMENTSINDIRECTEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLMultiDrawElementsIndirectEXT, std::move(params));
      }
      if (strcmp(nameToken, "glMultiDrawElementsInstancedANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLMULTIDRAWELEMENTSINSTANCEDANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLMultiDrawElementsInstancedANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<
              PFNGLMULTIDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEANGLEPROC>::type>(paramTokens,
                                                                                     strings);
          return CallCapture(EntryPoint::GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE,
                             std::move(params));
      }
      if (strcmp(nameToken, "glMultiTexCoord4f") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMULTITEXCOORD4FPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLMultiTexCoord4f, std::move(params));
      }
      if (strcmp(nameToken, "glMultiTexCoord4x") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMULTITEXCOORD4XPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLMultiTexCoord4x, std::move(params));
      }
      if (strcmp(nameToken, "glNamedBufferStorageExternalEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLNAMEDBUFFERSTORAGEEXTERNALEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLNamedBufferStorageExternalEXT, std::move(params));
      }
      if (strcmp(nameToken, "glNormal3f") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLNORMAL3FPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLNormal3f, std::move(params));
      }
      if (strcmp(nameToken, "glNormal3x") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLNORMAL3XPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLNormal3x, std::move(params));
      }
      if (strcmp(nameToken, "glNormalPointer") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLNORMALPOINTERPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLNormalPointer, std::move(params));
      }
      if (strcmp(nameToken, "glObjectLabel") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLOBJECTLABELPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLObjectLabel, std::move(params));
      }
      if (strcmp(nameToken, "glObjectLabelKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLOBJECTLABELKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLObjectLabelKHR, std::move(params));
      }
      if (strcmp(nameToken, "glObjectPtrLabel") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLOBJECTPTRLABELPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLObjectPtrLabel, std::move(params));
      }
      if (strcmp(nameToken, "glObjectPtrLabelKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLOBJECTPTRLABELKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLObjectPtrLabelKHR, std::move(params));
      }
      if (strcmp(nameToken, "glOrthof") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLORTHOFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLOrthof, std::move(params));
      }
      if (strcmp(nameToken, "glOrthox") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLORTHOXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLOrthox, std::move(params));
      }
      if (strcmp(nameToken, "glPatchParameteri") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPATCHPARAMETERIPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPatchParameteri, std::move(params));
      }
      if (strcmp(nameToken, "glPatchParameteriEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPATCHPARAMETERIEXTPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLPatchParameteriEXT, std::move(params));
      }
      if (strcmp(nameToken, "glPatchParameteriOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPATCHPARAMETERIOESPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLPatchParameteriOES, std::move(params));
      }
      if (strcmp(nameToken, "glPauseTransformFeedback") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPAUSETRANSFORMFEEDBACKPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLPauseTransformFeedback, std::move(params));
      }
      if (strcmp(nameToken, "glPixelLocalStorageBarrierANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPIXELLOCALSTORAGEBARRIERANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLPixelLocalStorageBarrierANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glPixelStorei") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPIXELSTOREIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLPixelStorei, std::move(params));
      }
      if (strcmp(nameToken, "glPointParameterf") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOINTPARAMETERFPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPointParameterf, std::move(params));
      }
      if (strcmp(nameToken, "glPointParameterfv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOINTPARAMETERFVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPointParameterfv, std::move(params));
      }
      if (strcmp(nameToken, "glPointParameterx") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOINTPARAMETERXPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPointParameterx, std::move(params));
      }
      if (strcmp(nameToken, "glPointParameterxv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOINTPARAMETERXVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPointParameterxv, std::move(params));
      }
      if (strcmp(nameToken, "glPointSize") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPOINTSIZEPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLPointSize, std::move(params));
      }
      if (strcmp(nameToken, "glPointSizePointerOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPOINTSIZEPOINTEROESPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLPointSizePointerOES, std::move(params));
      }
      if (strcmp(nameToken, "glPointSizex") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPOINTSIZEXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLPointSizex, std::move(params));
      }
      if (strcmp(nameToken, "glPolygonModeANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOLYGONMODEANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPolygonModeANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glPolygonModeNV") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOLYGONMODENVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPolygonModeNV, std::move(params));
      }
      if (strcmp(nameToken, "glPolygonOffset") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOLYGONOFFSETPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPolygonOffset, std::move(params));
      }
      if (strcmp(nameToken, "glPolygonOffsetClampEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPOLYGONOFFSETCLAMPEXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLPolygonOffsetClampEXT, std::move(params));
      }
      if (strcmp(nameToken, "glPolygonOffsetx") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOLYGONOFFSETXPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPolygonOffsetx, std::move(params));
      }
      if (strcmp(nameToken, "glPopDebugGroup") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOPDEBUGGROUPPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPopDebugGroup, std::move(params));
      }
      if (strcmp(nameToken, "glPopDebugGroupKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOPDEBUGGROUPKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPopDebugGroupKHR, std::move(params));
      }
      if (strcmp(nameToken, "glPopGroupMarkerEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOPGROUPMARKEREXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPopGroupMarkerEXT, std::move(params));
      }
      if (strcmp(nameToken, "glPopMatrix") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPOPMATRIXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLPopMatrix, std::move(params));
      }
      if (strcmp(nameToken, "glPrimitiveBoundingBox") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPRIMITIVEBOUNDINGBOXPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLPrimitiveBoundingBox, std::move(params));
      }
      if (strcmp(nameToken, "glPrimitiveBoundingBoxEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPRIMITIVEBOUNDINGBOXEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLPrimitiveBoundingBoxEXT, std::move(params));
      }
      if (strcmp(nameToken, "glPrimitiveBoundingBoxOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPRIMITIVEBOUNDINGBOXOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLPrimitiveBoundingBoxOES, std::move(params));
      }
      if (strcmp(nameToken, "glProgramBinary") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMBINARYPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramBinary, std::move(params));
      }
      if (strcmp(nameToken, "glProgramBinaryOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMBINARYOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramBinaryOES, std::move(params));
      }
      if (strcmp(nameToken, "glProgramParameteri") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMPARAMETERIPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramParameteri, std::move(params));
      }
      if (strcmp(nameToken, "glProgramParameteriEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMPARAMETERIEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramParameteriEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform1f") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1FPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform1f, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform1fEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1FEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLProgramUniform1fEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform1fv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1FVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform1fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform1fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1FVEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramUniform1fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform1i") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1IPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform1i, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform1iEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1IEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLProgramUniform1iEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform1iv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1IVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform1iv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform1ivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1IVEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramUniform1ivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform1ui") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1UIPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform1ui, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform1uiEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1UIEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramUniform1uiEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform1uiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1UIVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLProgramUniform1uiv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform1uivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1UIVEXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLProgramUniform1uivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform2f") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2FPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform2f, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform2fEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2FEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLProgramUniform2fEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform2fv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2FVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform2fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform2fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2FVEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramUniform2fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform2i") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2IPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform2i, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform2iEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2IEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLProgramUniform2iEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform2iv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2IVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform2iv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform2ivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2IVEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramUniform2ivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform2ui") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2UIPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform2ui, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform2uiEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2UIEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramUniform2uiEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform2uiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2UIVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLProgramUniform2uiv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform2uivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2UIVEXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLProgramUniform2uivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform3f") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3FPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform3f, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform3fEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3FEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLProgramUniform3fEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform3fv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3FVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform3fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform3fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3FVEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramUniform3fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform3i") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3IPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform3i, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform3iEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3IEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLProgramUniform3iEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform3iv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3IVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform3iv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform3ivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3IVEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramUniform3ivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform3ui") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3UIPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform3ui, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform3uiEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3UIEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramUniform3uiEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform3uiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3UIVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLProgramUniform3uiv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform3uivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3UIVEXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLProgramUniform3uivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform4f") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4FPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform4f, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform4fEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4FEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLProgramUniform4fEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform4fv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4FVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform4fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform4fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4FVEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramUniform4fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform4i") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4IPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform4i, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform4iEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4IEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLProgramUniform4iEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform4iv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4IVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform4iv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform4ivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4IVEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramUniform4ivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform4ui") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4UIPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniform4ui, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform4uiEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4UIEXTPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProgramUniform4uiEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform4uiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4UIVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLProgramUniform4uiv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniform4uivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4UIVEXTPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLProgramUniform4uivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix2fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2FVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix2fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix2fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix2fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix2x3fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix2x3fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix2x3fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix2x3fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix2x4fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix2x4fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix2x4fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix2x4fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix3fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3FVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix3fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix3fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix3fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix3x2fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix3x2fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix3x2fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix3x2fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix3x4fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix3x4fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix3x4fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix3x4fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix4fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4FVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix4fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix4fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix4fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix4x2fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix4x2fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix4x2fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix4x2fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix4x3fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix4x3fv, std::move(params));
      }
      if (strcmp(nameToken, "glProgramUniformMatrix4x3fvEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLProgramUniformMatrix4x3fvEXT, std::move(params));
      }
      if (strcmp(nameToken, "glProvokingVertexANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPROVOKINGVERTEXANGLEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLProvokingVertexANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glPushDebugGroup") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPUSHDEBUGGROUPPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPushDebugGroup, std::move(params));
      }
      if (strcmp(nameToken, "glPushDebugGroupKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPUSHDEBUGGROUPKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLPushDebugGroupKHR, std::move(params));
      }
      if (strcmp(nameToken, "glPushGroupMarkerEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPUSHGROUPMARKEREXTPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLPushGroupMarkerEXT, std::move(params));
      }
      if (strcmp(nameToken, "glPushMatrix") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLPUSHMATRIXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLPushMatrix, std::move(params));
      }
      if (strcmp(nameToken, "glQueryCounterEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLQUERYCOUNTEREXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLQueryCounterEXT, std::move(params));
      }
      if (strcmp(nameToken, "glQueryMatrixxOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLQUERYMATRIXXOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLQueryMatrixxOES, std::move(params));
      }
      if (strcmp(nameToken, "glReadBuffer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLREADBUFFERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLReadBuffer, std::move(params));
      }
      if (strcmp(nameToken, "glReadPixels") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLREADPIXELSPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLReadPixels, std::move(params));
      }
      if (strcmp(nameToken, "glReadPixelsRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLREADPIXELSROBUSTANGLEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLReadPixelsRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glReadnPixels") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLREADNPIXELSPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLReadnPixels, std::move(params));
      }
      if (strcmp(nameToken, "glReadnPixelsEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLREADNPIXELSEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLReadnPixelsEXT, std::move(params));
      }
      if (strcmp(nameToken, "glReadnPixelsKHR") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLREADNPIXELSKHRPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLReadnPixelsKHR, std::move(params));
      }
      if (strcmp(nameToken, "glReadnPixelsRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLREADNPIXELSROBUSTANGLEPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLReadnPixelsRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glReleaseShaderCompiler") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLRELEASESHADERCOMPILERPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLReleaseShaderCompiler, std::move(params));
      }
      if (strcmp(nameToken, "glReleaseTexturesANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLRELEASETEXTURESANGLEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLReleaseTexturesANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glRenderbufferStorage") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLRENDERBUFFERSTORAGEPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLRenderbufferStorage, std::move(params));
      }
      if (strcmp(nameToken, "glRenderbufferStorageMultisample") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLRenderbufferStorageMultisample, std::move(params));
      }
      if (strcmp(nameToken, "glRenderbufferStorageMultisampleANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLRenderbufferStorageMultisampleANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glRenderbufferStorageMultisampleEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLRenderbufferStorageMultisampleEXT, std::move(params));
      }
      if (strcmp(nameToken, "glRenderbufferStorageOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLRENDERBUFFERSTORAGEOESPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLRenderbufferStorageOES, std::move(params));
      }
      if (strcmp(nameToken, "glRequestExtensionANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLREQUESTEXTENSIONANGLEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLRequestExtensionANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glResumeTransformFeedback") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLRESUMETRANSFORMFEEDBACKPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLResumeTransformFeedback, std::move(params));
      }
      if (strcmp(nameToken, "glRotatef") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLROTATEFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLRotatef, std::move(params));
      }
      if (strcmp(nameToken, "glRotatex") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLROTATEXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLRotatex, std::move(params));
      }
      if (strcmp(nameToken, "glSampleCoverage") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLECOVERAGEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLSampleCoverage, std::move(params));
      }
      if (strcmp(nameToken, "glSampleCoveragex") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLECOVERAGEXPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLSampleCoveragex, std::move(params));
      }
      if (strcmp(nameToken, "glSampleMaski") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLEMASKIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLSampleMaski, std::move(params));
      }
      if (strcmp(nameToken, "glSampleMaskiANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLEMASKIANGLEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLSampleMaskiANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameterIiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIIVPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLSamplerParameterIiv, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameterIivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIIVEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLSamplerParameterIivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameterIivOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIIVOESPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLSamplerParameterIivOES, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameterIivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLSamplerParameterIivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameterIuiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIUIVPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLSamplerParameterIuiv, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameterIuivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIUIVEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLSamplerParameterIuivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameterIuivOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIUIVOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLSamplerParameterIuivOES, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameterIuivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIUIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLSamplerParameterIuivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameterf") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERFPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLSamplerParameterf, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameterfv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERFVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLSamplerParameterfv, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameterfvRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERFVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLSamplerParameterfvRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameteri") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLSamplerParameteri, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameteriv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLSamplerParameteriv, std::move(params));
      }
      if (strcmp(nameToken, "glSamplerParameterivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLSamplerParameterivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glScalef") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSCALEFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLScalef, std::move(params));
      }
      if (strcmp(nameToken, "glScalex") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSCALEXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLScalex, std::move(params));
      }
      if (strcmp(nameToken, "glScissor") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSCISSORPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLScissor, std::move(params));
      }
      if (strcmp(nameToken, "glSelectPerfMonitorCountersAMD") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSELECTPERFMONITORCOUNTERSAMDPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLSelectPerfMonitorCountersAMD, std::move(params));
      }
      if (strcmp(nameToken, "glSemaphoreParameterui64vEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSEMAPHOREPARAMETERUI64VEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLSemaphoreParameterui64vEXT, std::move(params));
      }
      if (strcmp(nameToken, "glSetFenceNV") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSETFENCENVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLSetFenceNV, std::move(params));
      }
      if (strcmp(nameToken, "glShadeModel") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSHADEMODELPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLShadeModel, std::move(params));
      }
      if (strcmp(nameToken, "glShaderBinary") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSHADERBINARYPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLShaderBinary, std::move(params));
      }
      if (strcmp(nameToken, "glShaderSource") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSHADERSOURCEPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLShaderSource, std::move(params));
      }
      if (strcmp(nameToken, "glShadingRateQCOM") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSHADINGRATEQCOMPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLShadingRateQCOM, std::move(params));
      }
      if (strcmp(nameToken, "glSignalSemaphoreEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSIGNALSEMAPHOREEXTPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLSignalSemaphoreEXT, std::move(params));
      }
      if (strcmp(nameToken, "glStartTilingQCOM") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSTARTTILINGQCOMPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLStartTilingQCOM, std::move(params));
      }
      if (strcmp(nameToken, "glStencilFunc") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSTENCILFUNCPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLStencilFunc, std::move(params));
      }
      if (strcmp(nameToken, "glStencilFuncSeparate") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSTENCILFUNCSEPARATEPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLStencilFuncSeparate, std::move(params));
      }
      if (strcmp(nameToken, "glStencilMask") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSTENCILMASKPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLStencilMask, std::move(params));
      }
      if (strcmp(nameToken, "glStencilMaskSeparate") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSTENCILMASKSEPARATEPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLStencilMaskSeparate, std::move(params));
      }
      if (strcmp(nameToken, "glStencilOp") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLSTENCILOPPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLStencilOp, std::move(params));
      }
      if (strcmp(nameToken, "glStencilOpSeparate") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSTENCILOPSEPARATEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLStencilOpSeparate, std::move(params));
      }
      if (strcmp(nameToken, "glTestFenceNV") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTESTFENCENVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTestFenceNV, std::move(params));
      }
      if (strcmp(nameToken, "glTexBuffer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXBUFFERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexBuffer, std::move(params));
      }
      if (strcmp(nameToken, "glTexBufferEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXBUFFEREXTPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexBufferEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexBufferOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXBUFFEROESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexBufferOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexBufferRange") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXBUFFERRANGEPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexBufferRange, std::move(params));
      }
      if (strcmp(nameToken, "glTexBufferRangeEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXBUFFERRANGEEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexBufferRangeEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexBufferRangeOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXBUFFERRANGEOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexBufferRangeOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexCoordPointer") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXCOORDPOINTERPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexCoordPointer, std::move(params));
      }
      if (strcmp(nameToken, "glTexEnvf") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXENVFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexEnvf, std::move(params));
      }
      if (strcmp(nameToken, "glTexEnvfv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXENVFVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexEnvfv, std::move(params));
      }
      if (strcmp(nameToken, "glTexEnvi") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXENVIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexEnvi, std::move(params));
      }
      if (strcmp(nameToken, "glTexEnviv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXENVIVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexEnviv, std::move(params));
      }
      if (strcmp(nameToken, "glTexEnvx") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXENVXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexEnvx, std::move(params));
      }
      if (strcmp(nameToken, "glTexEnvxv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXENVXVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexEnvxv, std::move(params));
      }
      if (strcmp(nameToken, "glTexGenfOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXGENFOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexGenfOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexGenfvOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXGENFVOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexGenfvOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexGeniOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXGENIOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexGeniOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexGenivOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXGENIVOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexGenivOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexGenxOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXGENXOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexGenxOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexGenxvOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXGENXVOESPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexGenxvOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexImage2D") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXIMAGE2DPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexImage2D, std::move(params));
      }
      if (strcmp(nameToken, "glTexImage2DExternalANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXIMAGE2DEXTERNALANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexImage2DExternalANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexImage2DRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXIMAGE2DROBUSTANGLEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLTexImage2DRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexImage3D") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXIMAGE3DPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexImage3D, std::move(params));
      }
      if (strcmp(nameToken, "glTexImage3DOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXIMAGE3DOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexImage3DOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexImage3DRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXIMAGE3DROBUSTANGLEPROC>::type>(paramTokens,
                                                                                         strings);
          return CallCapture(EntryPoint::GLTexImage3DRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterIiv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIIVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexParameterIiv, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterIivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIIVEXTPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLTexParameterIivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterIivOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIIVOESPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLTexParameterIivOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterIivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexParameterIivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterIuiv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIUIVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexParameterIuiv, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterIuivEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIUIVEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLTexParameterIuivEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterIuivOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIUIVOESPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLTexParameterIuivOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterIuivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIUIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexParameterIuivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterf") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERFPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexParameterf, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterfv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERFVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexParameterfv, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterfvRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERFVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexParameterfvRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameteri") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexParameteri, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameteriv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexParameteriv, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterivRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIVROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexParameterivRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterx") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERXPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexParameterx, std::move(params));
      }
      if (strcmp(nameToken, "glTexParameterxv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERXVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexParameterxv, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorage1DEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE1DEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorage1DEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorage2D") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE2DPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorage2D, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorage2DEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE2DEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorage2DEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorage2DMultisample") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE2DMULTISAMPLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorage2DMultisample, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorage2DMultisampleANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE2DMULTISAMPLEANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorage2DMultisampleANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorage3D") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE3DPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorage3D, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorage3DEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE3DEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorage3DEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorage3DMultisample") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE3DMULTISAMPLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorage3DMultisample, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorage3DMultisampleOES") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE3DMULTISAMPLEOESPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorage3DMultisampleOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorageAttribs2DEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEATTRIBS2DEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLTexStorageAttribs2DEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorageAttribs3DEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEATTRIBS3DEXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLTexStorageAttribs3DEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorageMem2DEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEM2DEXTPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLTexStorageMem2DEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorageMem2DMultisampleEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEM2DMULTISAMPLEEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorageMem2DMultisampleEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorageMem3DEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEM3DEXTPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLTexStorageMem3DEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorageMem3DMultisampleEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEM3DMULTISAMPLEEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorageMem3DMultisampleEXT, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorageMemFlags2DANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEMFLAGS2DANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorageMemFlags2DANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorageMemFlags2DMultisampleANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLTEXSTORAGEMEMFLAGS2DMULTISAMPLEANGLEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLTexStorageMemFlags2DMultisampleANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorageMemFlags3DANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEMFLAGS3DANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexStorageMemFlags3DANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexStorageMemFlags3DMultisampleANGLE") == 0)
      {
          ParamBuffer params = ParseParameters<
              std::remove_pointer<PFNGLTEXSTORAGEMEMFLAGS3DMULTISAMPLEANGLEPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLTexStorageMemFlags3DMultisampleANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexSubImage2D") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE2DPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexSubImage2D, std::move(params));
      }
      if (strcmp(nameToken, "glTexSubImage2DRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE2DROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexSubImage2DRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTexSubImage3D") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE3DPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexSubImage3D, std::move(params));
      }
      if (strcmp(nameToken, "glTexSubImage3DOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE3DOESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLTexSubImage3DOES, std::move(params));
      }
      if (strcmp(nameToken, "glTexSubImage3DRobustANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE3DROBUSTANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTexSubImage3DRobustANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glTextureFoveationParametersQCOM") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTextureFoveationParametersQCOM, std::move(params));
      }
      if (strcmp(nameToken, "glTransformFeedbackVaryings") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTRANSFORMFEEDBACKVARYINGSPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLTransformFeedbackVaryings, std::move(params));
      }
      if (strcmp(nameToken, "glTranslatef") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTRANSLATEFPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTranslatef, std::move(params));
      }
      if (strcmp(nameToken, "glTranslatex") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLTRANSLATEXPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLTranslatex, std::move(params));
      }
      if (strcmp(nameToken, "glUniform1f") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM1FPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform1f, std::move(params));
      }
      if (strcmp(nameToken, "glUniform1fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM1FVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform1fv, std::move(params));
      }
      if (strcmp(nameToken, "glUniform1i") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM1IPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform1i, std::move(params));
      }
      if (strcmp(nameToken, "glUniform1iv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM1IVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform1iv, std::move(params));
      }
      if (strcmp(nameToken, "glUniform1ui") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM1UIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform1ui, std::move(params));
      }
      if (strcmp(nameToken, "glUniform1uiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM1UIVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform1uiv, std::move(params));
      }
      if (strcmp(nameToken, "glUniform2f") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM2FPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform2f, std::move(params));
      }
      if (strcmp(nameToken, "glUniform2fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM2FVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform2fv, std::move(params));
      }
      if (strcmp(nameToken, "glUniform2i") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM2IPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform2i, std::move(params));
      }
      if (strcmp(nameToken, "glUniform2iv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM2IVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform2iv, std::move(params));
      }
      if (strcmp(nameToken, "glUniform2ui") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM2UIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform2ui, std::move(params));
      }
      if (strcmp(nameToken, "glUniform2uiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM2UIVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform2uiv, std::move(params));
      }
      if (strcmp(nameToken, "glUniform3f") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM3FPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform3f, std::move(params));
      }
      if (strcmp(nameToken, "glUniform3fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM3FVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform3fv, std::move(params));
      }
      if (strcmp(nameToken, "glUniform3i") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM3IPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform3i, std::move(params));
      }
      if (strcmp(nameToken, "glUniform3iv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM3IVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform3iv, std::move(params));
      }
      if (strcmp(nameToken, "glUniform3ui") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM3UIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform3ui, std::move(params));
      }
      if (strcmp(nameToken, "glUniform3uiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM3UIVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform3uiv, std::move(params));
      }
      if (strcmp(nameToken, "glUniform4f") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM4FPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform4f, std::move(params));
      }
      if (strcmp(nameToken, "glUniform4fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM4FVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform4fv, std::move(params));
      }
      if (strcmp(nameToken, "glUniform4i") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM4IPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform4i, std::move(params));
      }
      if (strcmp(nameToken, "glUniform4iv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM4IVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform4iv, std::move(params));
      }
      if (strcmp(nameToken, "glUniform4ui") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM4UIPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform4ui, std::move(params));
      }
      if (strcmp(nameToken, "glUniform4uiv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORM4UIVPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUniform4uiv, std::move(params));
      }
      if (strcmp(nameToken, "glUniformBlockBinding") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORMBLOCKBINDINGPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLUniformBlockBinding, std::move(params));
      }
      if (strcmp(nameToken, "glUniformMatrix2fv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX2FVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLUniformMatrix2fv, std::move(params));
      }
      if (strcmp(nameToken, "glUniformMatrix2x3fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX2X3FVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLUniformMatrix2x3fv, std::move(params));
      }
      if (strcmp(nameToken, "glUniformMatrix2x4fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX2X4FVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLUniformMatrix2x4fv, std::move(params));
      }
      if (strcmp(nameToken, "glUniformMatrix3fv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX3FVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLUniformMatrix3fv, std::move(params));
      }
      if (strcmp(nameToken, "glUniformMatrix3x2fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX3X2FVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLUniformMatrix3x2fv, std::move(params));
      }
      if (strcmp(nameToken, "glUniformMatrix3x4fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX3X4FVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLUniformMatrix3x4fv, std::move(params));
      }
      if (strcmp(nameToken, "glUniformMatrix4fv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX4FVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLUniformMatrix4fv, std::move(params));
      }
      if (strcmp(nameToken, "glUniformMatrix4x2fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX4X2FVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLUniformMatrix4x2fv, std::move(params));
      }
      if (strcmp(nameToken, "glUniformMatrix4x3fv") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX4X3FVPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLUniformMatrix4x3fv, std::move(params));
      }
      if (strcmp(nameToken, "glUnmapBuffer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUNMAPBUFFERPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUnmapBuffer, std::move(params));
      }
      if (strcmp(nameToken, "glUnmapBufferOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUNMAPBUFFEROESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLUnmapBufferOES, std::move(params));
      }
      if (strcmp(nameToken, "glUseProgram") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUSEPROGRAMPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLUseProgram, std::move(params));
      }
      if (strcmp(nameToken, "glUseProgramStages") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUSEPROGRAMSTAGESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLUseProgramStages, std::move(params));
      }
      if (strcmp(nameToken, "glUseProgramStagesEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLUSEPROGRAMSTAGESEXTPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLUseProgramStagesEXT, std::move(params));
      }
      if (strcmp(nameToken, "glValidateProgram") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVALIDATEPROGRAMPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLValidateProgram, std::move(params));
      }
      if (strcmp(nameToken, "glValidateProgramPipeline") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLVALIDATEPROGRAMPIPELINEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLValidateProgramPipeline, std::move(params));
      }
      if (strcmp(nameToken, "glValidateProgramPipelineEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLVALIDATEPROGRAMPIPELINEEXTPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLValidateProgramPipelineEXT, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttrib1f") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB1FPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttrib1f, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttrib1fv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB1FVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttrib1fv, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttrib2f") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB2FPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttrib2f, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttrib2fv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB2FVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttrib2fv, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttrib3f") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB3FPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttrib3f, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttrib3fv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB3FVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttrib3fv, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttrib4f") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB4FPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttrib4f, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttrib4fv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB4FVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttrib4fv, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttribBinding") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBBINDINGPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLVertexAttribBinding, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttribDivisor") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBDIVISORPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLVertexAttribDivisor, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttribDivisorANGLE") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBDIVISORANGLEPROC>::type>(
                  paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttribDivisorANGLE, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttribDivisorEXT") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBDIVISOREXTPROC>::type>(paramTokens,
                                                                                          strings);
          return CallCapture(EntryPoint::GLVertexAttribDivisorEXT, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttribFormat") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBFORMATPROC>::type>(paramTokens,
                                                                                      strings);
          return CallCapture(EntryPoint::GLVertexAttribFormat, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttribI4i") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBI4IPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttribI4i, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttribI4iv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBI4IVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttribI4iv, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttribI4ui") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBI4UIPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttribI4ui, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttribI4uiv") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBI4UIVPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexAttribI4uiv, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttribIFormat") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBIFORMATPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLVertexAttribIFormat, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttribIPointer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBIPOINTERPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLVertexAttribIPointer, std::move(params));
      }
      if (strcmp(nameToken, "glVertexAttribPointer") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBPOINTERPROC>::type>(paramTokens,
                                                                                       strings);
          return CallCapture(EntryPoint::GLVertexAttribPointer, std::move(params));
      }
      if (strcmp(nameToken, "glVertexBindingDivisor") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLVERTEXBINDINGDIVISORPROC>::type>(paramTokens,
                                                                                        strings);
          return CallCapture(EntryPoint::GLVertexBindingDivisor, std::move(params));
      }
      if (strcmp(nameToken, "glVertexPointer") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXPOINTERPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLVertexPointer, std::move(params));
      }
      if (strcmp(nameToken, "glViewport") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLVIEWPORTPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLViewport, std::move(params));
      }
      if (strcmp(nameToken, "glWaitSemaphoreEXT") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLWAITSEMAPHOREEXTPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLWaitSemaphoreEXT, std::move(params));
      }
      if (strcmp(nameToken, "glWaitSync") == 0)
      {
          ParamBuffer params =
              ParseParameters<std::remove_pointer<PFNGLWAITSYNCPROC>::type>(paramTokens, strings);
          return CallCapture(EntryPoint::GLWaitSync, std::move(params));
      }
      if (strcmp(nameToken, "glWeightPointerOES") == 0)
      {
          ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLWEIGHTPOINTEROESPROC>::type>(
              paramTokens, strings);
          return CallCapture(EntryPoint::GLWeightPointerOES, std::move(params));
      }
      if (strcmp(nameToken, "CreateContext") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(CreateContext)>(paramTokens, strings);
          return CallCapture("CreateContext", std::move(params));
      }
      if (strcmp(nameToken, "CreateEGLImage") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(CreateEGLImage)>(paramTokens, strings);
          return CallCapture("CreateEGLImage", std::move(params));
      }
      if (strcmp(nameToken, "CreateEGLImageKHR") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(CreateEGLImageKHR)>(paramTokens, strings);
          return CallCapture("CreateEGLImageKHR", std::move(params));
      }
      if (strcmp(nameToken, "CreateEGLSync") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(CreateEGLSync)>(paramTokens, strings);
          return CallCapture("CreateEGLSync", std::move(params));
      }
      if (strcmp(nameToken, "CreateEGLSyncKHR") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(CreateEGLSyncKHR)>(paramTokens, strings);
          return CallCapture("CreateEGLSyncKHR", std::move(params));
      }
      if (strcmp(nameToken, "CreateNativeClientBufferANDROID") == 0)
      {
          ParamBuffer params =
              ParseParameters<decltype(CreateNativeClientBufferANDROID)>(paramTokens, strings);
          return CallCapture("CreateNativeClientBufferANDROID", std::move(params));
      }
      if (strcmp(nameToken, "CreatePbufferSurface") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(CreatePbufferSurface)>(paramTokens, strings);
          return CallCapture("CreatePbufferSurface", std::move(params));
      }
      if (strcmp(nameToken, "CreateProgram") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(CreateProgram)>(paramTokens, strings);
          return CallCapture("CreateProgram", std::move(params));
      }
      if (strcmp(nameToken, "CreateShader") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(CreateShader)>(paramTokens, strings);
          return CallCapture("CreateShader", std::move(params));
      }
      if (strcmp(nameToken, "CreateShaderProgramv") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(CreateShaderProgramv)>(paramTokens, strings);
          return CallCapture("CreateShaderProgramv", std::move(params));
      }
      if (strcmp(nameToken, "DeleteUniformLocations") == 0)
      {
          ParamBuffer params =
              ParseParameters<decltype(DeleteUniformLocations)>(paramTokens, strings);
          return CallCapture("DeleteUniformLocations", std::move(params));
      }
      if (strcmp(nameToken, "DestroyEGLImage") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(DestroyEGLImage)>(paramTokens, strings);
          return CallCapture("DestroyEGLImage", std::move(params));
      }
      if (strcmp(nameToken, "DestroyEGLImageKHR") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(DestroyEGLImageKHR)>(paramTokens, strings);
          return CallCapture("DestroyEGLImageKHR", std::move(params));
      }
      if (strcmp(nameToken, "FenceSync") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(FenceSync)>(paramTokens, strings);
          return CallCapture("FenceSync", std::move(params));
      }
      if (strcmp(nameToken, "FenceSync2") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(FenceSync2)>(paramTokens, strings);
          return CallCapture("FenceSync2", std::move(params));
      }
      if (strcmp(nameToken, "InitializeReplay") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(InitializeReplay)>(paramTokens, strings);
          return CallCapture("InitializeReplay", std::move(params));
      }
      if (strcmp(nameToken, "InitializeReplay2") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(InitializeReplay2)>(paramTokens, strings);
          return CallCapture("InitializeReplay2", std::move(params));
      }
      if (strcmp(nameToken, "InitializeReplay3") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(InitializeReplay3)>(paramTokens, strings);
          return CallCapture("InitializeReplay3", std::move(params));
      }
      if (strcmp(nameToken, "InitializeReplay4") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(InitializeReplay4)>(paramTokens, strings);
          return CallCapture("InitializeReplay4", std::move(params));
      }
      if (strcmp(nameToken, "MapBufferOES") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(MapBufferOES)>(paramTokens, strings);
          return CallCapture("MapBufferOES", std::move(params));
      }
      if (strcmp(nameToken, "MapBufferRange") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(MapBufferRange)>(paramTokens, strings);
          return CallCapture("MapBufferRange", std::move(params));
      }
      if (strcmp(nameToken, "MapBufferRangeEXT") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(MapBufferRangeEXT)>(paramTokens, strings);
          return CallCapture("MapBufferRangeEXT", std::move(params));
      }
      if (strcmp(nameToken, "SetBufferID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(SetBufferID)>(paramTokens, strings);
          return CallCapture("SetBufferID", std::move(params));
      }
      if (strcmp(nameToken, "SetCurrentContextID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(SetCurrentContextID)>(paramTokens, strings);
          return CallCapture("SetCurrentContextID", std::move(params));
      }
      if (strcmp(nameToken, "SetFramebufferID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(SetFramebufferID)>(paramTokens, strings);
          return CallCapture("SetFramebufferID", std::move(params));
      }
      if (strcmp(nameToken, "SetFramebufferID2") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(SetFramebufferID2)>(paramTokens, strings);
          return CallCapture("SetFramebufferID2", std::move(params));
      }
      if (strcmp(nameToken, "SetRenderbufferID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(SetRenderbufferID)>(paramTokens, strings);
          return CallCapture("SetRenderbufferID", std::move(params));
      }
      if (strcmp(nameToken, "SetTextureID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(SetTextureID)>(paramTokens, strings);
          return CallCapture("SetTextureID", std::move(params));
      }
      if (strcmp(nameToken, "UniformBlockBinding") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UniformBlockBinding)>(paramTokens, strings);
          return CallCapture("UniformBlockBinding", std::move(params));
      }
      if (strcmp(nameToken, "UpdateBufferID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateBufferID)>(paramTokens, strings);
          return CallCapture("UpdateBufferID", std::move(params));
      }
      if (strcmp(nameToken, "UpdateClientArrayPointer") == 0)
      {
          ParamBuffer params =
              ParseParameters<decltype(UpdateClientArrayPointer)>(paramTokens, strings);
          return CallCapture("UpdateClientArrayPointer", std::move(params));
      }
      if (strcmp(nameToken, "UpdateClientBufferData") == 0)
      {
          ParamBuffer params =
              ParseParameters<decltype(UpdateClientBufferData)>(paramTokens, strings);
          return CallCapture("UpdateClientBufferData", std::move(params));
      }
      if (strcmp(nameToken, "UpdateClientBufferDataWithOffset") == 0)
      {
          ParamBuffer params =
              ParseParameters<decltype(UpdateClientBufferDataWithOffset)>(paramTokens, strings);
          return CallCapture("UpdateClientBufferDataWithOffset", std::move(params));
      }
      if (strcmp(nameToken, "UpdateCurrentProgram") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateCurrentProgram)>(paramTokens, strings);
          return CallCapture("UpdateCurrentProgram", std::move(params));
      }
      if (strcmp(nameToken, "UpdateFenceNVID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateFenceNVID)>(paramTokens, strings);
          return CallCapture("UpdateFenceNVID", std::move(params));
      }
      if (strcmp(nameToken, "UpdateFramebufferID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateFramebufferID)>(paramTokens, strings);
          return CallCapture("UpdateFramebufferID", std::move(params));
      }
      if (strcmp(nameToken, "UpdateFramebufferID2") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateFramebufferID2)>(paramTokens, strings);
          return CallCapture("UpdateFramebufferID2", std::move(params));
      }
      if (strcmp(nameToken, "UpdateMemoryObjectID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateMemoryObjectID)>(paramTokens, strings);
          return CallCapture("UpdateMemoryObjectID", std::move(params));
      }
      if (strcmp(nameToken, "UpdateProgramPipelineID") == 0)
      {
          ParamBuffer params =
              ParseParameters<decltype(UpdateProgramPipelineID)>(paramTokens, strings);
          return CallCapture("UpdateProgramPipelineID", std::move(params));
      }
      if (strcmp(nameToken, "UpdateQueryID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateQueryID)>(paramTokens, strings);
          return CallCapture("UpdateQueryID", std::move(params));
      }
      if (strcmp(nameToken, "UpdateRenderbufferID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateRenderbufferID)>(paramTokens, strings);
          return CallCapture("UpdateRenderbufferID", std::move(params));
      }
      if (strcmp(nameToken, "UpdateResourceIDBuffer") == 0)
      {
          ParamBuffer params =
              ParseParameters<decltype(UpdateResourceIDBuffer)>(paramTokens, strings);
          return CallCapture("UpdateResourceIDBuffer", std::move(params));
      }
      if (strcmp(nameToken, "UpdateSamplerID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateSamplerID)>(paramTokens, strings);
          return CallCapture("UpdateSamplerID", std::move(params));
      }
      if (strcmp(nameToken, "UpdateSemaphoreID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateSemaphoreID)>(paramTokens, strings);
          return CallCapture("UpdateSemaphoreID", std::move(params));
      }
      if (strcmp(nameToken, "UpdateShaderProgramID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateShaderProgramID)>(paramTokens, strings);
          return CallCapture("UpdateShaderProgramID", std::move(params));
      }
      if (strcmp(nameToken, "UpdateTextureID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateTextureID)>(paramTokens, strings);
          return CallCapture("UpdateTextureID", std::move(params));
      }
      if (strcmp(nameToken, "UpdateTransformFeedbackID") == 0)
      {
          ParamBuffer params =
              ParseParameters<decltype(UpdateTransformFeedbackID)>(paramTokens, strings);
          return CallCapture("UpdateTransformFeedbackID", std::move(params));
      }
      if (strcmp(nameToken, "UpdateUniformBlockIndex") == 0)
      {
          ParamBuffer params =
              ParseParameters<decltype(UpdateUniformBlockIndex)>(paramTokens, strings);
          return CallCapture("UpdateUniformBlockIndex", std::move(params));
      }
      if (strcmp(nameToken, "UpdateUniformLocation") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateUniformLocation)>(paramTokens, strings);
          return CallCapture("UpdateUniformLocation", std::move(params));
      }
      if (strcmp(nameToken, "UpdateVertexArrayID") == 0)
      {
          ParamBuffer params = ParseParameters<decltype(UpdateVertexArrayID)>(paramTokens, strings);
          return CallCapture("UpdateVertexArrayID", std::move(params));
      }
      if (strcmp(nameToken, "ValidateSerializedState") == 0)
      {
          ParamBuffer params =
              ParseParameters<decltype(ValidateSerializedState)>(paramTokens, strings);
          return CallCapture("ValidateSerializedState", std::move(params));
      }
  
      if (numParamTokens > 0)
      {
          printf("Expected zero parameter tokens for %s\n", nameToken);
          UNREACHABLE();
      }
      return CallCapture(nameToken, ParamBuffer());
  }
  
  template <typename Fn, EnableIfNArgs<Fn, 1> = 0>
  void DispatchCallCapture(Fn *fn, const Captures &cap)
  {
      (*fn)(Arg<Fn, 0>(cap));
  }
  
  template <typename Fn, EnableIfNArgs<Fn, 2> = 0>
  void DispatchCallCapture(Fn *fn, const Captures &cap)
  {
      (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap));
  }
  
  template <typename Fn, EnableIfNArgs<Fn, 3> = 0>
  void DispatchCallCapture(Fn *fn, const Captures &cap)
  {
      (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap));
  }
  
  template <typename Fn, EnableIfNArgs<Fn, 4> = 0>
  void DispatchCallCapture(Fn *fn, const Captures &cap)
  {
      (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap));
  }
  
  template <typename Fn, EnableIfNArgs<Fn, 5> = 0>
  void DispatchCallCapture(Fn *fn, const Captures &cap)
  {
      (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap));
  }
  
  template <typename Fn, EnableIfNArgs<Fn, 8> = 0>
  void DispatchCallCapture(Fn *fn, const Captures &cap)
  {
      (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
            Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap));
  }
  
  template <typename Fn, EnableIfNArgs<Fn, 16> = 0>
  void DispatchCallCapture(Fn *fn, const Captures &cap)
  {
      (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
            Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap), Arg<Fn, 8>(cap), Arg<Fn, 9>(cap),
            Arg<Fn, 10>(cap), Arg<Fn, 11>(cap), Arg<Fn, 12>(cap), Arg<Fn, 13>(cap), Arg<Fn, 14>(cap),
            Arg<Fn, 15>(cap));
  }
  
  template <typename Fn, EnableIfNArgs<Fn, 20> = 0>
  void DispatchCallCapture(Fn *fn, const Captures &cap)
  {
      (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
            Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap), Arg<Fn, 8>(cap), Arg<Fn, 9>(cap),
            Arg<Fn, 10>(cap), Arg<Fn, 11>(cap), Arg<Fn, 12>(cap), Arg<Fn, 13>(cap), Arg<Fn, 14>(cap),
            Arg<Fn, 15>(cap), Arg<Fn, 16>(cap), Arg<Fn, 17>(cap), Arg<Fn, 18>(cap), Arg<Fn, 19>(cap));
  }
  
  template <typename Fn, EnableIfNArgs<Fn, 22> = 0>
  void DispatchCallCapture(Fn *fn, const Captures &cap)
  {
      (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
            Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap), Arg<Fn, 8>(cap), Arg<Fn, 9>(cap),
            Arg<Fn, 10>(cap), Arg<Fn, 11>(cap), Arg<Fn, 12>(cap), Arg<Fn, 13>(cap), Arg<Fn, 14>(cap),
            Arg<Fn, 15>(cap), Arg<Fn, 16>(cap), Arg<Fn, 17>(cap), Arg<Fn, 18>(cap), Arg<Fn, 19>(cap),
            Arg<Fn, 20>(cap), Arg<Fn, 21>(cap));
  }
  
  template <typename Fn, EnableIfNArgs<Fn, 23> = 0>
  void DispatchCallCapture(Fn *fn, const Captures &cap)
  {
      (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
            Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap), Arg<Fn, 8>(cap), Arg<Fn, 9>(cap),
            Arg<Fn, 10>(cap), Arg<Fn, 11>(cap), Arg<Fn, 12>(cap), Arg<Fn, 13>(cap), Arg<Fn, 14>(cap),
            Arg<Fn, 15>(cap), Arg<Fn, 16>(cap), Arg<Fn, 17>(cap), Arg<Fn, 18>(cap), Arg<Fn, 19>(cap),
            Arg<Fn, 20>(cap), Arg<Fn, 21>(cap), Arg<Fn, 22>(cap));
  }
  
  void ReplayCustomFunctionCall(const CallCapture &call, const TraceFunctionMap &customFunctions)
  {
      ASSERT(call.entryPoint == EntryPoint::Invalid);
      const Captures &captures = call.params.getParamCaptures();
  
      if (call.customFunctionName == "CreateContext")
      {
          DispatchCallCapture(CreateContext, captures);
          return;
      }
      if (call.customFunctionName == "CreateEGLImage")
      {
          DispatchCallCapture(CreateEGLImage, captures);
          return;
      }
      if (call.customFunctionName == "CreateEGLImageKHR")
      {
          DispatchCallCapture(CreateEGLImageKHR, captures);
          return;
      }
      if (call.customFunctionName == "CreateEGLSync")
      {
          DispatchCallCapture(CreateEGLSync, captures);
          return;
      }
      if (call.customFunctionName == "CreateEGLSyncKHR")
      {
          DispatchCallCapture(CreateEGLSyncKHR, captures);
          return;
      }
      if (call.customFunctionName == "CreateNativeClientBufferANDROID")
      {
          DispatchCallCapture(CreateNativeClientBufferANDROID, captures);
          return;
      }
      if (call.customFunctionName == "CreatePbufferSurface")
      {
          DispatchCallCapture(CreatePbufferSurface, captures);
          return;
      }
      if (call.customFunctionName == "CreateProgram")
      {
          DispatchCallCapture(CreateProgram, captures);
          return;
      }
      if (call.customFunctionName == "CreateShader")
      {
          DispatchCallCapture(CreateShader, captures);
          return;
      }
      if (call.customFunctionName == "CreateShaderProgramv")
      {
          DispatchCallCapture(CreateShaderProgramv, captures);
          return;
      }
      if (call.customFunctionName == "DeleteUniformLocations")
      {
          DispatchCallCapture(DeleteUniformLocations, captures);
          return;
      }
      if (call.customFunctionName == "DestroyEGLImage")
      {
          DispatchCallCapture(DestroyEGLImage, captures);
          return;
      }
      if (call.customFunctionName == "DestroyEGLImageKHR")
      {
          DispatchCallCapture(DestroyEGLImageKHR, captures);
          return;
      }
      if (call.customFunctionName == "FenceSync")
      {
          DispatchCallCapture(FenceSync, captures);
          return;
      }
      if (call.customFunctionName == "FenceSync2")
      {
          DispatchCallCapture(FenceSync2, captures);
          return;
      }
      if (call.customFunctionName == "InitializeReplay")
      {
          DispatchCallCapture(InitializeReplay, captures);
          return;
      }
      if (call.customFunctionName == "InitializeReplay2")
      {
          DispatchCallCapture(InitializeReplay2, captures);
          return;
      }
      if (call.customFunctionName == "InitializeReplay3")
      {
          DispatchCallCapture(InitializeReplay3, captures);
          return;
      }
      if (call.customFunctionName == "InitializeReplay4")
      {
          DispatchCallCapture(InitializeReplay4, captures);
          return;
      }
      if (call.customFunctionName == "MapBufferOES")
      {
          DispatchCallCapture(MapBufferOES, captures);
          return;
      }
      if (call.customFunctionName == "MapBufferRange")
      {
          DispatchCallCapture(MapBufferRange, captures);
          return;
      }
      if (call.customFunctionName == "MapBufferRangeEXT")
      {
          DispatchCallCapture(MapBufferRangeEXT, captures);
          return;
      }
      if (call.customFunctionName == "SetBufferID")
      {
          DispatchCallCapture(SetBufferID, captures);
          return;
      }
      if (call.customFunctionName == "SetCurrentContextID")
      {
          DispatchCallCapture(SetCurrentContextID, captures);
          return;
      }
      if (call.customFunctionName == "SetFramebufferID")
      {
          DispatchCallCapture(SetFramebufferID, captures);
          return;
      }
      if (call.customFunctionName == "SetFramebufferID2")
      {
          DispatchCallCapture(SetFramebufferID2, captures);
          return;
      }
      if (call.customFunctionName == "SetRenderbufferID")
      {
          DispatchCallCapture(SetRenderbufferID, captures);
          return;
      }
      if (call.customFunctionName == "SetTextureID")
      {
          DispatchCallCapture(SetTextureID, captures);
          return;
      }
      if (call.customFunctionName == "UniformBlockBinding")
      {
          DispatchCallCapture(UniformBlockBinding, captures);
          return;
      }
      if (call.customFunctionName == "UpdateBufferID")
      {
          DispatchCallCapture(UpdateBufferID, captures);
          return;
      }
      if (call.customFunctionName == "UpdateClientArrayPointer")
      {
          DispatchCallCapture(UpdateClientArrayPointer, captures);
          return;
      }
      if (call.customFunctionName == "UpdateClientBufferData")
      {
          DispatchCallCapture(UpdateClientBufferData, captures);
          return;
      }
      if (call.customFunctionName == "UpdateClientBufferDataWithOffset")
      {
          DispatchCallCapture(UpdateClientBufferDataWithOffset, captures);
          return;
      }
      if (call.customFunctionName == "UpdateCurrentProgram")
      {
          DispatchCallCapture(UpdateCurrentProgram, captures);
          return;
      }
      if (call.customFunctionName == "UpdateFenceNVID")
      {
          DispatchCallCapture(UpdateFenceNVID, captures);
          return;
      }
      if (call.customFunctionName == "UpdateFramebufferID")
      {
          DispatchCallCapture(UpdateFramebufferID, captures);
          return;
      }
      if (call.customFunctionName == "UpdateFramebufferID2")
      {
          DispatchCallCapture(UpdateFramebufferID2, captures);
          return;
      }
      if (call.customFunctionName == "UpdateMemoryObjectID")
      {
          DispatchCallCapture(UpdateMemoryObjectID, captures);
          return;
      }
      if (call.customFunctionName == "UpdateProgramPipelineID")
      {
          DispatchCallCapture(UpdateProgramPipelineID, captures);
          return;
      }
      if (call.customFunctionName == "UpdateQueryID")
      {
          DispatchCallCapture(UpdateQueryID, captures);
          return;
      }
      if (call.customFunctionName == "UpdateRenderbufferID")
      {
          DispatchCallCapture(UpdateRenderbufferID, captures);
          return;
      }
      if (call.customFunctionName == "UpdateResourceIDBuffer")
      {
          DispatchCallCapture(UpdateResourceIDBuffer, captures);
          return;
      }
      if (call.customFunctionName == "UpdateSamplerID")
      {
          DispatchCallCapture(UpdateSamplerID, captures);
          return;
      }
      if (call.customFunctionName == "UpdateSemaphoreID")
      {
          DispatchCallCapture(UpdateSemaphoreID, captures);
          return;
      }
      if (call.customFunctionName == "UpdateShaderProgramID")
      {
          DispatchCallCapture(UpdateShaderProgramID, captures);
          return;
      }
      if (call.customFunctionName == "UpdateTextureID")
      {
          DispatchCallCapture(UpdateTextureID, captures);
          return;
      }
      if (call.customFunctionName == "UpdateTransformFeedbackID")
      {
          DispatchCallCapture(UpdateTransformFeedbackID, captures);
          return;
      }
      if (call.customFunctionName == "UpdateUniformBlockIndex")
      {
          DispatchCallCapture(UpdateUniformBlockIndex, captures);
          return;
      }
      if (call.customFunctionName == "UpdateUniformLocation")
      {
          DispatchCallCapture(UpdateUniformLocation, captures);
          return;
      }
      if (call.customFunctionName == "UpdateVertexArrayID")
      {
          DispatchCallCapture(UpdateVertexArrayID, captures);
          return;
      }
      if (call.customFunctionName == "ValidateSerializedState")
      {
          DispatchCallCapture(ValidateSerializedState, captures);
          return;
      }
  
      auto iter = customFunctions.find(call.customFunctionName);
      if (iter == customFunctions.end())
      {
          printf("Unknown custom function: %s\n", call.customFunctionName.c_str());
          UNREACHABLE();
      }
      else
      {
          ASSERT(call.params.empty());
          const TraceFunction &customFunc = iter->second;
          for (const CallCapture &customCall : customFunc)
          {
              ReplayTraceFunctionCall(customCall, customFunctions);
          }
      }
  }
  }  // namespace angle
  

Download