text: #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <glad/egl.h>
  
  #ifndef GLAD_IMPL_UTIL_C_
  #define GLAD_IMPL_UTIL_C_
  
  #if _MSC_VER >= 1400
  #define GLAD_IMPL_UTIL_STRNCPY(dest, source, len) strncpy_s(dest, len, source, len - 1);
  #else
  #define GLAD_IMPL_UTIL_STRNCPY(dest, source, len) strncpy(dest, source, len);
  #endif
  
  #ifdef _MSC_VER
  #define GLAD_IMPL_UTIL_SSCANF sscanf_s
  #else
  #define GLAD_IMPL_UTIL_SSCANF sscanf
  #endif
  
  #endif /* GLAD_IMPL_UTIL_C_ */
  
  int GLAD_EGL_VERSION_1_0;
  int GLAD_EGL_VERSION_1_1;
  int GLAD_EGL_VERSION_1_2;
  int GLAD_EGL_VERSION_1_3;
  int GLAD_EGL_VERSION_1_4;
  int GLAD_EGL_VERSION_1_5;
  int GLAD_EGL_EXT_platform_device;
  int GLAD_EGL_EXT_platform_base;
  int GLAD_EGL_NV_device_cuda;
  int GLAD_EGL_EXT_device_enumeration;
  int GLAD_EGL_EXT_device_query;
  int GLAD_EGL_EXT_device_base;
  int GLAD_EGL_NV_cuda_event;
  
  PFNEGLQUERYDEVICESEXTPROC glad_eglQueryDevicesEXT;
  PFNEGLCREATEPBUFFERSURFACEPROC glad_eglCreatePbufferSurface;
  PFNEGLGETERRORPROC glad_eglGetError;
  PFNEGLGETPROCADDRESSPROC glad_eglGetProcAddress;
  PFNEGLGETCURRENTDISPLAYPROC glad_eglGetCurrentDisplay;
  PFNEGLQUERYAPIPROC glad_eglQueryAPI;
  PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC glad_eglCreatePlatformPixmapSurface;
  PFNEGLQUERYDISPLAYATTRIBKHRPROC glad_eglQueryDisplayAttribKHR;
  PFNEGLDESTROYSYNCPROC glad_eglDestroySync;
  PFNEGLCREATEIMAGEPROC glad_eglCreateImage;
  PFNEGLQUERYCONTEXTPROC glad_eglQueryContext;
  PFNEGLSWAPBUFFERSPROC glad_eglSwapBuffers;
  PFNEGLCREATECONTEXTPROC glad_eglCreateContext;
  PFNEGLCHOOSECONFIGPROC glad_eglChooseConfig;
  PFNEGLBINDAPIPROC glad_eglBindAPI;
  PFNEGLWAITNATIVEPROC glad_eglWaitNative;
  PFNEGLTERMINATEPROC glad_eglTerminate;
  PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC glad_eglCreatePlatformPixmapSurfaceEXT;
  PFNEGLRELEASETHREADPROC glad_eglReleaseThread;
  PFNEGLCREATEPLATFORMWINDOWSURFACEPROC glad_eglCreatePlatformWindowSurface;
  PFNEGLGETCONFIGATTRIBPROC glad_eglGetConfigAttrib;
  PFNEGLGETCURRENTSURFACEPROC glad_eglGetCurrentSurface;
  PFNEGLCOPYBUFFERSPROC glad_eglCopyBuffers;
  PFNEGLGETPLATFORMDISPLAYEXTPROC glad_eglGetPlatformDisplayEXT;
  PFNEGLQUERYDEVICEATTRIBEXTPROC glad_eglQueryDeviceAttribEXT;
  PFNEGLCREATEPIXMAPSURFACEPROC glad_eglCreatePixmapSurface;
  PFNEGLBINDTEXIMAGEPROC glad_eglBindTexImage;
  PFNEGLGETPLATFORMDISPLAYPROC glad_eglGetPlatformDisplay;
  PFNEGLGETDISPLAYPROC glad_eglGetDisplay;
  PFNEGLQUERYSTRINGPROC glad_eglQueryString;
  PFNEGLCLIENTWAITSYNCPROC glad_eglClientWaitSync;
  PFNEGLWAITSYNCPROC glad_eglWaitSync;
  PFNEGLDESTROYIMAGEPROC glad_eglDestroyImage;
  PFNEGLRELEASETEXIMAGEPROC glad_eglReleaseTexImage;
  PFNEGLQUERYDISPLAYATTRIBEXTPROC glad_eglQueryDisplayAttribEXT;
  PFNEGLDESTROYCONTEXTPROC glad_eglDestroyContext;
  PFNEGLQUERYDEVICESTRINGEXTPROC glad_eglQueryDeviceStringEXT;
  PFNEGLCREATEWINDOWSURFACEPROC glad_eglCreateWindowSurface;
  PFNEGLGETCURRENTCONTEXTPROC glad_eglGetCurrentContext;
  PFNEGLINITIALIZEPROC glad_eglInitialize;
  PFNEGLDESTROYSURFACEPROC glad_eglDestroySurface;
  PFNEGLMAKECURRENTPROC glad_eglMakeCurrent;
  PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC glad_eglCreatePlatformWindowSurfaceEXT;
  PFNEGLSWAPINTERVALPROC glad_eglSwapInterval;
  PFNEGLCREATESYNCPROC glad_eglCreateSync;
  PFNEGLGETSYNCATTRIBPROC glad_eglGetSyncAttrib;
  PFNEGLSURFACEATTRIBPROC glad_eglSurfaceAttrib;
  PFNEGLWAITGLPROC glad_eglWaitGL;
  PFNEGLQUERYSURFACEPROC glad_eglQuerySurface;
  PFNEGLGETCONFIGSPROC glad_eglGetConfigs;
  PFNEGLWAITCLIENTPROC glad_eglWaitClient;
  PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC glad_eglCreatePbufferFromClientBuffer;
  
  static void load_EGL_VERSION_1_0(GLADuserptrloadfunc load, void *userptr)
  {
  	if (!GLAD_EGL_VERSION_1_0) return;
  	eglCreatePbufferSurface = (PFNEGLCREATEPBUFFERSURFACEPROC)load("eglCreatePbufferSurface", userptr);
  	eglGetError = (PFNEGLGETERRORPROC)load("eglGetError", userptr);
  	eglGetProcAddress = (PFNEGLGETPROCADDRESSPROC)load("eglGetProcAddress", userptr);
  	eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC)load("eglGetCurrentDisplay", userptr);
  	eglQueryContext = (PFNEGLQUERYCONTEXTPROC)load("eglQueryContext", userptr);
  	eglSwapBuffers = (PFNEGLSWAPBUFFERSPROC)load("eglSwapBuffers", userptr);
  	eglCreateContext = (PFNEGLCREATECONTEXTPROC)load("eglCreateContext", userptr);
  	eglChooseConfig = (PFNEGLCHOOSECONFIGPROC)load("eglChooseConfig", userptr);
  	eglWaitNative = (PFNEGLWAITNATIVEPROC)load("eglWaitNative", userptr);
  	eglTerminate = (PFNEGLTERMINATEPROC)load("eglTerminate", userptr);
  	eglCopyBuffers = (PFNEGLCOPYBUFFERSPROC)load("eglCopyBuffers", userptr);
  	eglGetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC)load("eglGetConfigAttrib", userptr);
  	eglGetCurrentSurface = (PFNEGLGETCURRENTSURFACEPROC)load("eglGetCurrentSurface", userptr);
  	eglCreatePixmapSurface = (PFNEGLCREATEPIXMAPSURFACEPROC)load("eglCreatePixmapSurface", userptr);
  	eglGetDisplay = (PFNEGLGETDISPLAYPROC)load("eglGetDisplay", userptr);
  	eglQueryString = (PFNEGLQUERYSTRINGPROC)load("eglQueryString", userptr);
  	eglDestroyContext = (PFNEGLDESTROYCONTEXTPROC)load("eglDestroyContext", userptr);
  	eglCreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC)load("eglCreateWindowSurface", userptr);
  	eglInitialize = (PFNEGLINITIALIZEPROC)load("eglInitialize", userptr);
  	eglDestroySurface = (PFNEGLDESTROYSURFACEPROC)load("eglDestroySurface", userptr);
  	eglMakeCurrent = (PFNEGLMAKECURRENTPROC)load("eglMakeCurrent", userptr);
  	eglWaitGL = (PFNEGLWAITGLPROC)load("eglWaitGL", userptr);
  	eglQuerySurface = (PFNEGLQUERYSURFACEPROC)load("eglQuerySurface", userptr);
  	eglGetConfigs = (PFNEGLGETCONFIGSPROC)load("eglGetConfigs", userptr);
  }
  static void load_EGL_VERSION_1_1(GLADuserptrloadfunc load, void *userptr)
  {
  	if (!GLAD_EGL_VERSION_1_1) return;
  	eglReleaseTexImage = (PFNEGLRELEASETEXIMAGEPROC)load("eglReleaseTexImage", userptr);
  	eglSurfaceAttrib = (PFNEGLSURFACEATTRIBPROC)load("eglSurfaceAttrib", userptr);
  	eglBindTexImage = (PFNEGLBINDTEXIMAGEPROC)load("eglBindTexImage", userptr);
  	eglSwapInterval = (PFNEGLSWAPINTERVALPROC)load("eglSwapInterval", userptr);
  }
  static void load_EGL_VERSION_1_2(GLADuserptrloadfunc load, void *userptr)
  {
  	if (!GLAD_EGL_VERSION_1_2) return;
  	eglBindAPI = (PFNEGLBINDAPIPROC)load("eglBindAPI", userptr);
  	eglQueryAPI = (PFNEGLQUERYAPIPROC)load("eglQueryAPI", userptr);
  	eglWaitClient = (PFNEGLWAITCLIENTPROC)load("eglWaitClient", userptr);
  	eglCreatePbufferFromClientBuffer = (PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC)load("eglCreatePbufferFromClientBuffer", userptr);
  	eglReleaseThread = (PFNEGLRELEASETHREADPROC)load("eglReleaseThread", userptr);
  }
  static void load_EGL_VERSION_1_4(GLADuserptrloadfunc load, void *userptr)
  {
  	if (!GLAD_EGL_VERSION_1_4) return;
  	eglGetCurrentContext = (PFNEGLGETCURRENTCONTEXTPROC)load("eglGetCurrentContext", userptr);
  }
  static void load_EGL_VERSION_1_5(GLADuserptrloadfunc load, void *userptr)
  {
  	if (!GLAD_EGL_VERSION_1_5) return;
  	eglDestroySync = (PFNEGLDESTROYSYNCPROC)load("eglDestroySync", userptr);
  	eglCreateImage = (PFNEGLCREATEIMAGEPROC)load("eglCreateImage", userptr);
  	eglGetPlatformDisplay = (PFNEGLGETPLATFORMDISPLAYPROC)load("eglGetPlatformDisplay", userptr);
  	eglDestroyImage = (PFNEGLDESTROYIMAGEPROC)load("eglDestroyImage", userptr);
  	eglClientWaitSync = (PFNEGLCLIENTWAITSYNCPROC)load("eglClientWaitSync", userptr);
  	eglWaitSync = (PFNEGLWAITSYNCPROC)load("eglWaitSync", userptr);
  	eglCreateSync = (PFNEGLCREATESYNCPROC)load("eglCreateSync", userptr);
  	eglGetSyncAttrib = (PFNEGLGETSYNCATTRIBPROC)load("eglGetSyncAttrib", userptr);
  	eglCreatePlatformWindowSurface = (PFNEGLCREATEPLATFORMWINDOWSURFACEPROC)load("eglCreatePlatformWindowSurface", userptr);
  	eglCreatePlatformPixmapSurface = (PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC)load("eglCreatePlatformPixmapSurface", userptr);
  }
  static void load_EGL_EXT_platform_base(GLADuserptrloadfunc load, void *userptr)
  {
  	if (!GLAD_EGL_EXT_platform_base) return;
  	eglCreatePlatformWindowSurfaceEXT = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)load("eglCreatePlatformWindowSurfaceEXT", userptr);
  	eglGetPlatformDisplayEXT = (PFNEGLGETPLATFORMDISPLAYEXTPROC)load("eglGetPlatformDisplayEXT", userptr);
  	eglCreatePlatformPixmapSurfaceEXT = (PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC)load("eglCreatePlatformPixmapSurfaceEXT", userptr);
  }
  static void load_EGL_EXT_device_enumeration(GLADuserptrloadfunc load, void *userptr)
  {
  	if (!GLAD_EGL_EXT_device_enumeration) return;
  	eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC)load("eglQueryDevicesEXT", userptr);
  }
  static void load_EGL_EXT_device_query(GLADuserptrloadfunc load, void *userptr)
  {
  	if (!GLAD_EGL_EXT_device_query) return;
  	eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC)load("eglQueryDisplayAttribEXT", userptr);
  	eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC)load("eglQueryDeviceStringEXT", userptr);
  	eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC)load("eglQueryDeviceAttribEXT", userptr);
  	eglQueryDisplayAttribKHR = (PFNEGLQUERYDISPLAYATTRIBKHRPROC)load("eglQueryDisplayAttribKHR", userptr);
  }
  static void load_EGL_EXT_device_base(GLADuserptrloadfunc load, void *userptr)
  {
  	if (!GLAD_EGL_EXT_device_base) return;
  	eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC)load("eglQueryDisplayAttribEXT", userptr);
  	eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC)load("eglQueryDevicesEXT", userptr);
  	eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC)load("eglQueryDeviceStringEXT", userptr);
  	eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC)load("eglQueryDeviceAttribEXT", userptr);
  	eglQueryDisplayAttribKHR = (PFNEGLQUERYDISPLAYATTRIBKHRPROC)load("eglQueryDisplayAttribKHR", userptr);
  }
  
  static int get_exts(EGLDisplay display, const char **extensions)
  {
  	*extensions = eglQueryString(display, EGL_EXTENSIONS);
  
  	return extensions != NULL;
  }
  
  static int has_ext(const char *extensions, const char *ext)
  {
  	const char *loc;
  	const char *terminator;
  	if (extensions == NULL)
  	{
  		return 0;
  	}
  	while (1)
  	{
  		loc = strstr(extensions, ext);
  		if (loc == NULL)
  		{
  			return 0;
  		}
  		terminator = loc + strlen(ext);
  		if ((loc == extensions || *(loc - 1) == ' ') &&
  			(*terminator == ' ' || *terminator == '\0'))
  		{
  			return 1;
  		}
  		extensions = terminator;
  	}
  }
  
  static GLADapiproc glad_egl_get_proc_from_userptr(const char *name, void *userptr)
  {
  	return (GLAD_GNUC_EXTENSION(GLADapiproc(*)(const char *name)) userptr)(name);
  }
  
  static int find_extensionsEGL(EGLDisplay display)
  {
  	const char *extensions;
  	if (!get_exts(display, &extensions)) return 0;
  
  	GLAD_EGL_EXT_platform_device = has_ext(extensions, "EGL_EXT_platform_device");
  	GLAD_EGL_EXT_platform_base = has_ext(extensions, "EGL_EXT_platform_base");
  	GLAD_EGL_NV_device_cuda = has_ext(extensions, "EGL_NV_device_cuda");
  	GLAD_EGL_EXT_device_enumeration = has_ext(extensions, "EGL_EXT_device_enumeration");
  	GLAD_EGL_EXT_device_query = has_ext(extensions, "EGL_EXT_device_query");
  	GLAD_EGL_EXT_device_base = has_ext(extensions, "EGL_EXT_device_base");
  	GLAD_EGL_NV_cuda_event = has_ext(extensions, "EGL_NV_cuda_event");
  
  	return 1;
  }
  
  static int find_coreEGL(EGLDisplay display)
  {
  	int major, minor;
  	const char *version;
  
  	if (display == NULL)
  	{
  		display = EGL_NO_DISPLAY; /* this is usually NULL, better safe than sorry */
  	}
  	if (display == EGL_NO_DISPLAY)
  	{
  		display = eglGetCurrentDisplay();
  	}
  	if (display == EGL_NO_DISPLAY)
  	{
  		display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  	}
  	if (display == EGL_NO_DISPLAY)
  	{
  		return 0;
  	}
  
  	version = eglQueryString(display, EGL_VERSION);
  	(void)eglGetError();
  
  	if (version == NULL)
  	{
  		major = 1;
  		minor = 0;
  	}
  	else
  	{
  		GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor);
  	}
  
  	GLAD_EGL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
  	GLAD_EGL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
  	GLAD_EGL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
  	GLAD_EGL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
  	GLAD_EGL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
  	GLAD_EGL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1;
  
  	return GLAD_MAKE_VERSION(major, minor);
  }
  
  int gladLoadEGLUserPtr(EGLDisplay display, GLADuserptrloadfunc load, void *userptr)
  {
  	int version;
  	eglGetDisplay = (PFNEGLGETDISPLAYPROC)load("eglGetDisplay", userptr);
  	eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC)load("eglGetCurrentDisplay", userptr);
  	eglQueryString = (PFNEGLQUERYSTRINGPROC)load("eglQueryString", userptr);
  	eglGetError = (PFNEGLGETERRORPROC)load("eglGetError", userptr);
  	if (eglGetDisplay == NULL || eglGetCurrentDisplay == NULL || eglQueryString == NULL || eglGetError == NULL) return 0;
  
  	version = find_coreEGL(display);
  	if (!version) return 0;
  	load_EGL_VERSION_1_0(load, userptr);
  	load_EGL_VERSION_1_1(load, userptr);
  	load_EGL_VERSION_1_2(load, userptr);
  	load_EGL_VERSION_1_4(load, userptr);
  	load_EGL_VERSION_1_5(load, userptr);
  
  	if (!find_extensionsEGL(display)) return 0;
  	load_EGL_EXT_platform_base(load, userptr);
  	load_EGL_EXT_device_enumeration(load, userptr);
  	load_EGL_EXT_device_query(load, userptr);
  	load_EGL_EXT_device_base(load, userptr);
  
  	return version;
  }
  
  int gladLoadEGL(EGLDisplay display, GLADloadfunc load)
  {
  	return gladLoadEGLUserPtr(display, glad_egl_get_proc_from_userptr, GLAD_GNUC_EXTENSION(void *) load);
  }
  
  #ifdef GLAD_EGL
  
  #ifndef GLAD_LOADER_LIBRARY_C_
  #define GLAD_LOADER_LIBRARY_C_
  
  #include <stddef.h>
  #include <stdlib.h>
  
  #if GLAD_PLATFORM_WIN32
  #include <windows.h>
  #else
  #include <dlfcn.h>
  #endif
  
  static void *glad_get_dlopen_handle(const char *lib_names[], int length)
  {
  	void *handle = NULL;
  	int i;
  
  	for (i = 0; i < length; ++i)
  	{
  #if GLAD_PLATFORM_WIN32
  #if GLAD_PLATFORM_UWP
  		size_t buffer_size = (strlen(lib_names[i]) + 1) * sizeof(WCHAR);
  		LPWSTR buffer = (LPWSTR)malloc(buffer_size);
  		if (buffer != NULL)
  		{
  			int ret = MultiByteToWideChar(CP_ACP, 0, lib_names[i], -1, buffer, buffer_size);
  			if (ret != 0)
  			{
  				handle = (void *)LoadPackagedLibrary(buffer, 0);
  			}
  			free((void *)buffer);
  		}
  #else
  		handle = (void *)LoadLibraryA(lib_names[i]);
  #endif
  #else
  		handle = dlopen(lib_names[i], RTLD_LAZY | RTLD_LOCAL);
  #endif
  		if (handle != NULL)
  		{
  			return handle;
  		}
  	}
  
  	return NULL;
  }
  
  static void glad_close_dlopen_handle(void *handle)
  {
  	if (handle != NULL)
  	{
  #if GLAD_PLATFORM_WIN32
  		FreeLibrary((HMODULE)handle);
  #else
  		dlclose(handle);
  #endif
  	}
  }
  
  static GLADapiproc glad_dlsym_handle(void *handle, const char *name)
  {
  	if (handle == NULL)
  	{
  		return NULL;
  	}
  
  #if GLAD_PLATFORM_WIN32
  	return (GLADapiproc)GetProcAddress((HMODULE)handle, name);
  #else
  	return GLAD_GNUC_EXTENSION(GLADapiproc) dlsym(handle, name);
  #endif
  }
  
  #endif /* GLAD_LOADER_LIBRARY_C_ */
  
  struct _glad_egl_userptr
  {
  	void *handle;
  	PFNEGLGETPROCADDRESSPROC get_proc_address_ptr;
  };
  
  static GLADapiproc glad_egl_get_proc(const char *name, void *vuserptr)
  {
  	struct _glad_egl_userptr userptr = *(struct _glad_egl_userptr *)vuserptr;
  	GLADapiproc result = NULL;
  
  	result = glad_dlsym_handle(userptr.handle, name);
  	if (result == NULL)
  	{
  		result = GLAD_GNUC_EXTENSION(GLADapiproc) userptr.get_proc_address_ptr(name);
  	}
  
  	return result;
  }
  
  static void *_egl_handle = NULL;
  
  int gladLoaderLoadEGL(EGLDisplay display)
  {
  #ifdef __APPLE__
  	static const char *NAMES[] = {"libEGL.dylib"};
  #elif GLAD_PLATFORM_WIN32
  	static const char *NAMES[] = {"libEGL.dll", "EGL.dll"};
  #else
  	static const char *NAMES[] = {"libEGL.so.1", "libEGL.so"};
  #endif
  
  	int version = 0;
  	int did_load = 0;
  	struct _glad_egl_userptr userptr;
  
  	if (_egl_handle == NULL)
  	{
  		_egl_handle = glad_get_dlopen_handle(NAMES, sizeof(NAMES) / sizeof(NAMES[0]));
  		did_load = _egl_handle != NULL;
  	}
  
  	if (_egl_handle != NULL)
  	{
  		userptr.handle = _egl_handle;
  		userptr.get_proc_address_ptr = (PFNEGLGETPROCADDRESSPROC)glad_dlsym_handle(_egl_handle, "eglGetProcAddress");
  		if (userptr.get_proc_address_ptr != NULL)
  		{
  			version = gladLoadEGLUserPtr(display, glad_egl_get_proc, &userptr);
  		}
  
  		if (!version && did_load)
  		{
  			glad_close_dlopen_handle(_egl_handle);
  			_egl_handle = NULL;
  		}
  	}
  
  	return version;
  }
  
  void gladLoaderUnloadEGL()
  {
  	if (_egl_handle != NULL)
  	{
  		glad_close_dlopen_handle(_egl_handle);
  		_egl_handle = NULL;
  	}
  }
  
  #endif /* GLAD_EGL */
  