From c37c8d60e3b7c68c2a3564d95f9958403d3b9d5c Mon Sep 17 00:00:00 2001 From: Humza Shahid Date: Mon, 30 Sep 2024 13:43:43 +0100 Subject: [PATCH] init --- build-unix.sh | 8 + ffi/export.h | 168 +++ ffi/glad.c | 1463 ++++++++++++++++++++++ ffi/glad.h | 2749 ++++++++++++++++++++++++++++++++++++++++++ ffi/gles3-export.c | 99 ++ ffi/gles3-import.sml | 58 + ffi/glfw-export.c | 43 + ffi/glfw-import.sml | 25 + ffi/glfw-input.c | 8 + ffi/glfw-input.sml | 12 + ffi/khrplatform.h | 282 +++++ shell/shell.sml | 34 + shf | Bin 0 -> 837688 bytes shf.mlb | 17 + 14 files changed, 4966 insertions(+) create mode 100755 build-unix.sh create mode 100644 ffi/export.h create mode 100644 ffi/glad.c create mode 100644 ffi/glad.h create mode 100644 ffi/gles3-export.c create mode 100644 ffi/gles3-import.sml create mode 100644 ffi/glfw-export.c create mode 100644 ffi/glfw-import.sml create mode 100644 ffi/glfw-input.c create mode 100644 ffi/glfw-input.sml create mode 100644 ffi/khrplatform.h create mode 100644 shell/shell.sml create mode 100755 shf create mode 100644 shf.mlb diff --git a/build-unix.sh b/build-unix.sh new file mode 100755 index 0000000..ca4f7bd --- /dev/null +++ b/build-unix.sh @@ -0,0 +1,8 @@ +#!/bin/sh +mlton -link-opt "$(pkg-config --cflags glfw3) $(pkg-config --static --libs glfw3)" \ + -export-header ffi/export.h \ + shf.mlb \ + ffi/glad.c \ + ffi/glfw-export.c \ + ffi/gles3-export.c \ + ffi/glfw-input.c diff --git a/ffi/export.h b/ffi/export.h new file mode 100644 index 0000000..ec6f560 --- /dev/null +++ b/ffi/export.h @@ -0,0 +1,168 @@ +#ifndef __SHF_ML_H__ +#define __SHF_ML_H__ + +/* Copyright (C) 2004-2007 Henry Cejtin, Matthew Fluet, Suresh + * Jagannathan, and Stephen Weeks. + * + * MLton is released under a HPND-style license. + * See the file MLton-LICENSE for details. + */ + +#ifndef _MLTON_MLTYPES_H_ +#define _MLTON_MLTYPES_H_ + +/* We need these because in header files for exported SML functions, + * types.h is included without cenv.h. + */ +#if (defined (_AIX) || defined (__hpux__) || defined (__OpenBSD__)) +#include +#elif (defined (__sun__)) +#include +#else +#include +#endif + +/* ML types */ +typedef unsigned char PointerAux __attribute__ ((may_alias)); +typedef PointerAux* Pointer; +#define Array(t) Pointer +#define Ref(t) Pointer +#define Vector(t) Pointer + +typedef int8_t Int8_t; +typedef int8_t Int8; +typedef int16_t Int16_t; +typedef int16_t Int16; +typedef int32_t Int32_t; +typedef int32_t Int32; +typedef int64_t Int64_t; +typedef int64_t Int64; +typedef float Real32_t; +typedef float Real32; +typedef double Real64_t; +typedef double Real64; +typedef uint8_t Word8_t; +typedef uint8_t Word8; +typedef uint16_t Word16_t; +typedef uint16_t Word16; +typedef uint32_t Word32_t; +typedef uint32_t Word32; +typedef uint64_t Word64_t; +typedef uint64_t Word64; + +typedef Int8_t WordS8_t; +typedef Int8_t WordS8; +typedef Int16_t WordS16_t; +typedef Int16_t WordS16; +typedef Int32_t WordS32_t; +typedef Int32_t WordS32; +typedef Int64_t WordS64_t; +typedef Int64_t WordS64; + +typedef Word8_t WordU8_t; +typedef Word8_t WordU8; +typedef Word16_t WordU16_t; +typedef Word16_t WordU16; +typedef Word32_t WordU32_t; +typedef Word32_t WordU32; +typedef Word64_t WordU64_t; +typedef Word64_t WordU64; + +typedef WordU8_t Char8_t; +typedef WordU8_t Char8; +typedef WordU16_t Char16_t; +typedef WordU16_t Char16; +typedef WordU32_t Char32_t; +typedef WordU32_t Char32; + +typedef Vector(Char8_t) String8_t; +typedef Vector(Char8_t) String8; +typedef Vector(Char16_t) String16_t; +typedef Vector(Char16_t) String16; +typedef Vector(Char32_t) String32_t; +typedef Vector(Char32_t) String32; + +typedef Int32_t Bool_t; +typedef Int32_t Bool; +typedef String8_t NullString8_t; +typedef String8_t NullString8; + +typedef void* CPointer; +typedef Pointer Objptr; + +#endif /* _MLTON_MLTYPES_H_ */ + +/* Copyright (C) 1999-2007 Henry Cejtin, Matthew Fluet, Suresh + * Jagannathan, and Stephen Weeks. + * Copyright (C) 1997-2000 NEC Research Institute. + * + * MLton is released under a HPND-style license. + * See the file MLton-LICENSE for details. + */ + +#ifndef _MLTON_EXPORT_H_ +#define _MLTON_EXPORT_H_ + +/* ------------------------------------------------- */ +/* Symbols */ +/* ------------------------------------------------- */ + +/* An external symbol is something not defined by the module + * (executable or library) being built. Rather, it is provided + * from a library dependency (dll, dylib, or shared object). + * + * A public symbol is defined in this module as being available + * to users outside of this module. If building a library, this + * means the symbol will be part of the public interface. + * + * A private symbol is defined within this module, but will not + * be made available outside of it. This is typically used for + * internal implementation details that should not be accessible. + */ + +#if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__) +#define EXTERNAL __declspec(dllimport) +#define PUBLIC __declspec(dllexport) +#define PRIVATE +#else +#define EXTERNAL __attribute__((visibility("default"))) +#define PUBLIC __attribute__((visibility("default"))) +#define PRIVATE __attribute__((visibility("hidden"))) +#endif + +#endif /* _MLTON_EXPORT_H_ */ + +#if !defined(PART_OF_SHF) && \ + !defined(STATIC_LINK_SHF) && \ + !defined(DYNAMIC_LINK_SHF) +#define PART_OF_SHF +#endif + +#if defined(PART_OF_SHF) +#define MLLIB_PRIVATE(x) PRIVATE x +#define MLLIB_PUBLIC(x) PUBLIC x +#elif defined(STATIC_LINK_SHF) +#define MLLIB_PRIVATE(x) +#define MLLIB_PUBLIC(x) PUBLIC x +#elif defined(DYNAMIC_LINK_SHF) +#define MLLIB_PRIVATE(x) +#define MLLIB_PUBLIC(x) EXTERNAL x +#else +#error Must specify linkage for shf +#define MLLIB_PRIVATE(x) +#define MLLIB_PUBLIC(x) +#endif + +#ifdef __cplusplus +extern "C" { +#endif + + +#undef MLLIB_PRIVATE +#undef MLLIB_PUBLIC + +#ifdef __cplusplus +} +#endif + +#endif /* __SHF_ML_H__ */ diff --git a/ffi/glad.c b/ffi/glad.c new file mode 100644 index 0000000..a9c0cb0 --- /dev/null +++ b/ffi/glad.c @@ -0,0 +1,1463 @@ +/* + + OpenGL loader generated by glad 0.1.27 on Tue Sep 4 23:27:29 2018. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=2.1 + Profile: compatibility + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + + Commandline: + --profile="compatibility" --api="gl=2.1" --generator="c" --spec="gl" --extensions="" + Online: + http://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gl%3D2.1 +*/ + +#include +#include +#include +#include "glad.h" + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + unsigned int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)realloc((void *)exts_i, (size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < (unsigned)num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == 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; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +PFNGLACCUMPROC glad_glAccum = NULL; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLALPHAFUNCPROC glad_glAlphaFunc = NULL; +PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident = NULL; +PFNGLARRAYELEMENTPROC glad_glArrayElement = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINPROC glad_glBegin = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBITMAPPROC glad_glBitmap = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCALLLISTPROC glad_glCallList = NULL; +PFNGLCALLLISTSPROC glad_glCallLists = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARACCUMPROC glad_glClearAccum = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARINDEXPROC glad_glClearIndex = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture = NULL; +PFNGLCLIPPLANEPROC glad_glClipPlane = NULL; +PFNGLCOLOR3BPROC glad_glColor3b = NULL; +PFNGLCOLOR3BVPROC glad_glColor3bv = NULL; +PFNGLCOLOR3DPROC glad_glColor3d = NULL; +PFNGLCOLOR3DVPROC glad_glColor3dv = NULL; +PFNGLCOLOR3FPROC glad_glColor3f = NULL; +PFNGLCOLOR3FVPROC glad_glColor3fv = NULL; +PFNGLCOLOR3IPROC glad_glColor3i = NULL; +PFNGLCOLOR3IVPROC glad_glColor3iv = NULL; +PFNGLCOLOR3SPROC glad_glColor3s = NULL; +PFNGLCOLOR3SVPROC glad_glColor3sv = NULL; +PFNGLCOLOR3UBPROC glad_glColor3ub = NULL; +PFNGLCOLOR3UBVPROC glad_glColor3ubv = NULL; +PFNGLCOLOR3UIPROC glad_glColor3ui = NULL; +PFNGLCOLOR3UIVPROC glad_glColor3uiv = NULL; +PFNGLCOLOR3USPROC glad_glColor3us = NULL; +PFNGLCOLOR3USVPROC glad_glColor3usv = NULL; +PFNGLCOLOR4BPROC glad_glColor4b = NULL; +PFNGLCOLOR4BVPROC glad_glColor4bv = NULL; +PFNGLCOLOR4DPROC glad_glColor4d = NULL; +PFNGLCOLOR4DVPROC glad_glColor4dv = NULL; +PFNGLCOLOR4FPROC glad_glColor4f = NULL; +PFNGLCOLOR4FVPROC glad_glColor4fv = NULL; +PFNGLCOLOR4IPROC glad_glColor4i = NULL; +PFNGLCOLOR4IVPROC glad_glColor4iv = NULL; +PFNGLCOLOR4SPROC glad_glColor4s = NULL; +PFNGLCOLOR4SVPROC glad_glColor4sv = NULL; +PFNGLCOLOR4UBPROC glad_glColor4ub = NULL; +PFNGLCOLOR4UBVPROC glad_glColor4ubv = NULL; +PFNGLCOLOR4UIPROC glad_glColor4ui = NULL; +PFNGLCOLOR4UIVPROC glad_glColor4uiv = NULL; +PFNGLCOLOR4USPROC glad_glColor4us = NULL; +PFNGLCOLOR4USVPROC glad_glColor4usv = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMATERIALPROC glad_glColorMaterial = NULL; +PFNGLCOLORPOINTERPROC glad_glColorPointer = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYPIXELSPROC glad_glCopyPixels = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETELISTSPROC glad_glDeleteLists = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWPIXELSPROC glad_glDrawPixels = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLEDGEFLAGPROC glad_glEdgeFlag = NULL; +PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer = NULL; +PFNGLEDGEFLAGVPROC glad_glEdgeFlagv = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENDPROC glad_glEnd = NULL; +PFNGLENDLISTPROC glad_glEndList = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLEVALCOORD1DPROC glad_glEvalCoord1d = NULL; +PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv = NULL; +PFNGLEVALCOORD1FPROC glad_glEvalCoord1f = NULL; +PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv = NULL; +PFNGLEVALCOORD2DPROC glad_glEvalCoord2d = NULL; +PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv = NULL; +PFNGLEVALCOORD2FPROC glad_glEvalCoord2f = NULL; +PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv = NULL; +PFNGLEVALMESH1PROC glad_glEvalMesh1 = NULL; +PFNGLEVALMESH2PROC glad_glEvalMesh2 = NULL; +PFNGLEVALPOINT1PROC glad_glEvalPoint1 = NULL; +PFNGLEVALPOINT2PROC glad_glEvalPoint2 = NULL; +PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer = NULL; +PFNGLFOGCOORDDPROC glad_glFogCoordd = NULL; +PFNGLFOGCOORDDVPROC glad_glFogCoorddv = NULL; +PFNGLFOGCOORDFPROC glad_glFogCoordf = NULL; +PFNGLFOGCOORDFVPROC glad_glFogCoordfv = NULL; +PFNGLFOGFPROC glad_glFogf = NULL; +PFNGLFOGFVPROC glad_glFogfv = NULL; +PFNGLFOGIPROC glad_glFogi = NULL; +PFNGLFOGIVPROC glad_glFogiv = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLFRUSTUMPROC glad_glFrustum = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENLISTSPROC glad_glGenLists = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCLIPPLANEPROC glad_glGetClipPlane = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETLIGHTFVPROC glad_glGetLightfv = NULL; +PFNGLGETLIGHTIVPROC glad_glGetLightiv = NULL; +PFNGLGETMAPDVPROC glad_glGetMapdv = NULL; +PFNGLGETMAPFVPROC glad_glGetMapfv = NULL; +PFNGLGETMAPIVPROC glad_glGetMapiv = NULL; +PFNGLGETMATERIALFVPROC glad_glGetMaterialfv = NULL; +PFNGLGETMATERIALIVPROC glad_glGetMaterialiv = NULL; +PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv = NULL; +PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv = NULL; +PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv = NULL; +PFNGLGETPOINTERVPROC glad_glGetPointerv = NULL; +PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv = NULL; +PFNGLGETTEXENVIVPROC glad_glGetTexEnviv = NULL; +PFNGLGETTEXGENDVPROC glad_glGetTexGendv = NULL; +PFNGLGETTEXGENFVPROC glad_glGetTexGenfv = NULL; +PFNGLGETTEXGENIVPROC glad_glGetTexGeniv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLINDEXMASKPROC glad_glIndexMask = NULL; +PFNGLINDEXPOINTERPROC glad_glIndexPointer = NULL; +PFNGLINDEXDPROC glad_glIndexd = NULL; +PFNGLINDEXDVPROC glad_glIndexdv = NULL; +PFNGLINDEXFPROC glad_glIndexf = NULL; +PFNGLINDEXFVPROC glad_glIndexfv = NULL; +PFNGLINDEXIPROC glad_glIndexi = NULL; +PFNGLINDEXIVPROC glad_glIndexiv = NULL; +PFNGLINDEXSPROC glad_glIndexs = NULL; +PFNGLINDEXSVPROC glad_glIndexsv = NULL; +PFNGLINDEXUBPROC glad_glIndexub = NULL; +PFNGLINDEXUBVPROC glad_glIndexubv = NULL; +PFNGLINITNAMESPROC glad_glInitNames = NULL; +PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISLISTPROC glad_glIsList = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLLIGHTMODELFPROC glad_glLightModelf = NULL; +PFNGLLIGHTMODELFVPROC glad_glLightModelfv = NULL; +PFNGLLIGHTMODELIPROC glad_glLightModeli = NULL; +PFNGLLIGHTMODELIVPROC glad_glLightModeliv = NULL; +PFNGLLIGHTFPROC glad_glLightf = NULL; +PFNGLLIGHTFVPROC glad_glLightfv = NULL; +PFNGLLIGHTIPROC glad_glLighti = NULL; +PFNGLLIGHTIVPROC glad_glLightiv = NULL; +PFNGLLINESTIPPLEPROC glad_glLineStipple = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLISTBASEPROC glad_glListBase = NULL; +PFNGLLOADIDENTITYPROC glad_glLoadIdentity = NULL; +PFNGLLOADMATRIXDPROC glad_glLoadMatrixd = NULL; +PFNGLLOADMATRIXFPROC glad_glLoadMatrixf = NULL; +PFNGLLOADNAMEPROC glad_glLoadName = NULL; +PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd = NULL; +PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAP1DPROC glad_glMap1d = NULL; +PFNGLMAP1FPROC glad_glMap1f = NULL; +PFNGLMAP2DPROC glad_glMap2d = NULL; +PFNGLMAP2FPROC glad_glMap2f = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPGRID1DPROC glad_glMapGrid1d = NULL; +PFNGLMAPGRID1FPROC glad_glMapGrid1f = NULL; +PFNGLMAPGRID2DPROC glad_glMapGrid2d = NULL; +PFNGLMAPGRID2FPROC glad_glMapGrid2f = NULL; +PFNGLMATERIALFPROC glad_glMaterialf = NULL; +PFNGLMATERIALFVPROC glad_glMaterialfv = NULL; +PFNGLMATERIALIPROC glad_glMateriali = NULL; +PFNGLMATERIALIVPROC glad_glMaterialiv = NULL; +PFNGLMATRIXMODEPROC glad_glMatrixMode = NULL; +PFNGLMULTMATRIXDPROC glad_glMultMatrixd = NULL; +PFNGLMULTMATRIXFPROC glad_glMultMatrixf = NULL; +PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd = NULL; +PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d = NULL; +PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv = NULL; +PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f = NULL; +PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv = NULL; +PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i = NULL; +PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv = NULL; +PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s = NULL; +PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv = NULL; +PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d = NULL; +PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv = NULL; +PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f = NULL; +PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv = NULL; +PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i = NULL; +PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv = NULL; +PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s = NULL; +PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv = NULL; +PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d = NULL; +PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv = NULL; +PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f = NULL; +PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv = NULL; +PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i = NULL; +PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv = NULL; +PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s = NULL; +PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv = NULL; +PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d = NULL; +PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv = NULL; +PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f = NULL; +PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv = NULL; +PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i = NULL; +PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv = NULL; +PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s = NULL; +PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv = NULL; +PFNGLNEWLISTPROC glad_glNewList = NULL; +PFNGLNORMAL3BPROC glad_glNormal3b = NULL; +PFNGLNORMAL3BVPROC glad_glNormal3bv = NULL; +PFNGLNORMAL3DPROC glad_glNormal3d = NULL; +PFNGLNORMAL3DVPROC glad_glNormal3dv = NULL; +PFNGLNORMAL3FPROC glad_glNormal3f = NULL; +PFNGLNORMAL3FVPROC glad_glNormal3fv = NULL; +PFNGLNORMAL3IPROC glad_glNormal3i = NULL; +PFNGLNORMAL3IVPROC glad_glNormal3iv = NULL; +PFNGLNORMAL3SPROC glad_glNormal3s = NULL; +PFNGLNORMAL3SVPROC glad_glNormal3sv = NULL; +PFNGLNORMALPOINTERPROC glad_glNormalPointer = NULL; +PFNGLORTHOPROC glad_glOrtho = NULL; +PFNGLPASSTHROUGHPROC glad_glPassThrough = NULL; +PFNGLPIXELMAPFVPROC glad_glPixelMapfv = NULL; +PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv = NULL; +PFNGLPIXELMAPUSVPROC glad_glPixelMapusv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf = NULL; +PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi = NULL; +PFNGLPIXELZOOMPROC glad_glPixelZoom = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple = NULL; +PFNGLPOPATTRIBPROC glad_glPopAttrib = NULL; +PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib = NULL; +PFNGLPOPMATRIXPROC glad_glPopMatrix = NULL; +PFNGLPOPNAMEPROC glad_glPopName = NULL; +PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures = NULL; +PFNGLPUSHATTRIBPROC glad_glPushAttrib = NULL; +PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib = NULL; +PFNGLPUSHMATRIXPROC glad_glPushMatrix = NULL; +PFNGLPUSHNAMEPROC glad_glPushName = NULL; +PFNGLRASTERPOS2DPROC glad_glRasterPos2d = NULL; +PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv = NULL; +PFNGLRASTERPOS2FPROC glad_glRasterPos2f = NULL; +PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv = NULL; +PFNGLRASTERPOS2IPROC glad_glRasterPos2i = NULL; +PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv = NULL; +PFNGLRASTERPOS2SPROC glad_glRasterPos2s = NULL; +PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv = NULL; +PFNGLRASTERPOS3DPROC glad_glRasterPos3d = NULL; +PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv = NULL; +PFNGLRASTERPOS3FPROC glad_glRasterPos3f = NULL; +PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv = NULL; +PFNGLRASTERPOS3IPROC glad_glRasterPos3i = NULL; +PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv = NULL; +PFNGLRASTERPOS3SPROC glad_glRasterPos3s = NULL; +PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv = NULL; +PFNGLRASTERPOS4DPROC glad_glRasterPos4d = NULL; +PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv = NULL; +PFNGLRASTERPOS4FPROC glad_glRasterPos4f = NULL; +PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv = NULL; +PFNGLRASTERPOS4IPROC glad_glRasterPos4i = NULL; +PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv = NULL; +PFNGLRASTERPOS4SPROC glad_glRasterPos4s = NULL; +PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRECTDPROC glad_glRectd = NULL; +PFNGLRECTDVPROC glad_glRectdv = NULL; +PFNGLRECTFPROC glad_glRectf = NULL; +PFNGLRECTFVPROC glad_glRectfv = NULL; +PFNGLRECTIPROC glad_glRecti = NULL; +PFNGLRECTIVPROC glad_glRectiv = NULL; +PFNGLRECTSPROC glad_glRects = NULL; +PFNGLRECTSVPROC glad_glRectsv = NULL; +PFNGLRENDERMODEPROC glad_glRenderMode = NULL; +PFNGLROTATEDPROC glad_glRotated = NULL; +PFNGLROTATEFPROC glad_glRotatef = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSCALEDPROC glad_glScaled = NULL; +PFNGLSCALEFPROC glad_glScalef = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b = NULL; +PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv = NULL; +PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d = NULL; +PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv = NULL; +PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f = NULL; +PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv = NULL; +PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i = NULL; +PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv = NULL; +PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s = NULL; +PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv = NULL; +PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub = NULL; +PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv = NULL; +PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui = NULL; +PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv = NULL; +PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us = NULL; +PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv = NULL; +PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer = NULL; +PFNGLSELECTBUFFERPROC glad_glSelectBuffer = NULL; +PFNGLSHADEMODELPROC glad_glShadeModel = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXCOORD1DPROC glad_glTexCoord1d = NULL; +PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv = NULL; +PFNGLTEXCOORD1FPROC glad_glTexCoord1f = NULL; +PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv = NULL; +PFNGLTEXCOORD1IPROC glad_glTexCoord1i = NULL; +PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv = NULL; +PFNGLTEXCOORD1SPROC glad_glTexCoord1s = NULL; +PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv = NULL; +PFNGLTEXCOORD2DPROC glad_glTexCoord2d = NULL; +PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv = NULL; +PFNGLTEXCOORD2FPROC glad_glTexCoord2f = NULL; +PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv = NULL; +PFNGLTEXCOORD2IPROC glad_glTexCoord2i = NULL; +PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv = NULL; +PFNGLTEXCOORD2SPROC glad_glTexCoord2s = NULL; +PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv = NULL; +PFNGLTEXCOORD3DPROC glad_glTexCoord3d = NULL; +PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv = NULL; +PFNGLTEXCOORD3FPROC glad_glTexCoord3f = NULL; +PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv = NULL; +PFNGLTEXCOORD3IPROC glad_glTexCoord3i = NULL; +PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv = NULL; +PFNGLTEXCOORD3SPROC glad_glTexCoord3s = NULL; +PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv = NULL; +PFNGLTEXCOORD4DPROC glad_glTexCoord4d = NULL; +PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv = NULL; +PFNGLTEXCOORD4FPROC glad_glTexCoord4f = NULL; +PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv = NULL; +PFNGLTEXCOORD4IPROC glad_glTexCoord4i = NULL; +PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv = NULL; +PFNGLTEXCOORD4SPROC glad_glTexCoord4s = NULL; +PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv = NULL; +PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer = NULL; +PFNGLTEXENVFPROC glad_glTexEnvf = NULL; +PFNGLTEXENVFVPROC glad_glTexEnvfv = NULL; +PFNGLTEXENVIPROC glad_glTexEnvi = NULL; +PFNGLTEXENVIVPROC glad_glTexEnviv = NULL; +PFNGLTEXGENDPROC glad_glTexGend = NULL; +PFNGLTEXGENDVPROC glad_glTexGendv = NULL; +PFNGLTEXGENFPROC glad_glTexGenf = NULL; +PFNGLTEXGENFVPROC glad_glTexGenfv = NULL; +PFNGLTEXGENIPROC glad_glTexGeni = NULL; +PFNGLTEXGENIVPROC glad_glTexGeniv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSLATEDPROC glad_glTranslated = NULL; +PFNGLTRANSLATEFPROC glad_glTranslatef = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEX2DPROC glad_glVertex2d = NULL; +PFNGLVERTEX2DVPROC glad_glVertex2dv = NULL; +PFNGLVERTEX2FPROC glad_glVertex2f = NULL; +PFNGLVERTEX2FVPROC glad_glVertex2fv = NULL; +PFNGLVERTEX2IPROC glad_glVertex2i = NULL; +PFNGLVERTEX2IVPROC glad_glVertex2iv = NULL; +PFNGLVERTEX2SPROC glad_glVertex2s = NULL; +PFNGLVERTEX2SVPROC glad_glVertex2sv = NULL; +PFNGLVERTEX3DPROC glad_glVertex3d = NULL; +PFNGLVERTEX3DVPROC glad_glVertex3dv = NULL; +PFNGLVERTEX3FPROC glad_glVertex3f = NULL; +PFNGLVERTEX3FVPROC glad_glVertex3fv = NULL; +PFNGLVERTEX3IPROC glad_glVertex3i = NULL; +PFNGLVERTEX3IVPROC glad_glVertex3iv = NULL; +PFNGLVERTEX3SPROC glad_glVertex3s = NULL; +PFNGLVERTEX3SVPROC glad_glVertex3sv = NULL; +PFNGLVERTEX4DPROC glad_glVertex4d = NULL; +PFNGLVERTEX4DVPROC glad_glVertex4dv = NULL; +PFNGLVERTEX4FPROC glad_glVertex4f = NULL; +PFNGLVERTEX4FVPROC glad_glVertex4fv = NULL; +PFNGLVERTEX4IPROC glad_glVertex4i = NULL; +PFNGLVERTEX4IVPROC glad_glVertex4iv = NULL; +PFNGLVERTEX4SPROC glad_glVertex4s = NULL; +PFNGLVERTEX4SVPROC glad_glVertex4sv = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXPOINTERPROC glad_glVertexPointer = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWINDOWPOS2DPROC glad_glWindowPos2d = NULL; +PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv = NULL; +PFNGLWINDOWPOS2FPROC glad_glWindowPos2f = NULL; +PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv = NULL; +PFNGLWINDOWPOS2IPROC glad_glWindowPos2i = NULL; +PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv = NULL; +PFNGLWINDOWPOS2SPROC glad_glWindowPos2s = NULL; +PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv = NULL; +PFNGLWINDOWPOS3DPROC glad_glWindowPos3d = NULL; +PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv = NULL; +PFNGLWINDOWPOS3FPROC glad_glWindowPos3f = NULL; +PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv = NULL; +PFNGLWINDOWPOS3IPROC glad_glWindowPos3i = NULL; +PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv = NULL; +PFNGLWINDOWPOS3SPROC glad_glWindowPos3s = NULL; +PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); + glad_glNewList = (PFNGLNEWLISTPROC)load("glNewList"); + glad_glEndList = (PFNGLENDLISTPROC)load("glEndList"); + glad_glCallList = (PFNGLCALLLISTPROC)load("glCallList"); + glad_glCallLists = (PFNGLCALLLISTSPROC)load("glCallLists"); + glad_glDeleteLists = (PFNGLDELETELISTSPROC)load("glDeleteLists"); + glad_glGenLists = (PFNGLGENLISTSPROC)load("glGenLists"); + glad_glListBase = (PFNGLLISTBASEPROC)load("glListBase"); + glad_glBegin = (PFNGLBEGINPROC)load("glBegin"); + glad_glBitmap = (PFNGLBITMAPPROC)load("glBitmap"); + glad_glColor3b = (PFNGLCOLOR3BPROC)load("glColor3b"); + glad_glColor3bv = (PFNGLCOLOR3BVPROC)load("glColor3bv"); + glad_glColor3d = (PFNGLCOLOR3DPROC)load("glColor3d"); + glad_glColor3dv = (PFNGLCOLOR3DVPROC)load("glColor3dv"); + glad_glColor3f = (PFNGLCOLOR3FPROC)load("glColor3f"); + glad_glColor3fv = (PFNGLCOLOR3FVPROC)load("glColor3fv"); + glad_glColor3i = (PFNGLCOLOR3IPROC)load("glColor3i"); + glad_glColor3iv = (PFNGLCOLOR3IVPROC)load("glColor3iv"); + glad_glColor3s = (PFNGLCOLOR3SPROC)load("glColor3s"); + glad_glColor3sv = (PFNGLCOLOR3SVPROC)load("glColor3sv"); + glad_glColor3ub = (PFNGLCOLOR3UBPROC)load("glColor3ub"); + glad_glColor3ubv = (PFNGLCOLOR3UBVPROC)load("glColor3ubv"); + glad_glColor3ui = (PFNGLCOLOR3UIPROC)load("glColor3ui"); + glad_glColor3uiv = (PFNGLCOLOR3UIVPROC)load("glColor3uiv"); + glad_glColor3us = (PFNGLCOLOR3USPROC)load("glColor3us"); + glad_glColor3usv = (PFNGLCOLOR3USVPROC)load("glColor3usv"); + glad_glColor4b = (PFNGLCOLOR4BPROC)load("glColor4b"); + glad_glColor4bv = (PFNGLCOLOR4BVPROC)load("glColor4bv"); + glad_glColor4d = (PFNGLCOLOR4DPROC)load("glColor4d"); + glad_glColor4dv = (PFNGLCOLOR4DVPROC)load("glColor4dv"); + glad_glColor4f = (PFNGLCOLOR4FPROC)load("glColor4f"); + glad_glColor4fv = (PFNGLCOLOR4FVPROC)load("glColor4fv"); + glad_glColor4i = (PFNGLCOLOR4IPROC)load("glColor4i"); + glad_glColor4iv = (PFNGLCOLOR4IVPROC)load("glColor4iv"); + glad_glColor4s = (PFNGLCOLOR4SPROC)load("glColor4s"); + glad_glColor4sv = (PFNGLCOLOR4SVPROC)load("glColor4sv"); + glad_glColor4ub = (PFNGLCOLOR4UBPROC)load("glColor4ub"); + glad_glColor4ubv = (PFNGLCOLOR4UBVPROC)load("glColor4ubv"); + glad_glColor4ui = (PFNGLCOLOR4UIPROC)load("glColor4ui"); + glad_glColor4uiv = (PFNGLCOLOR4UIVPROC)load("glColor4uiv"); + glad_glColor4us = (PFNGLCOLOR4USPROC)load("glColor4us"); + glad_glColor4usv = (PFNGLCOLOR4USVPROC)load("glColor4usv"); + glad_glEdgeFlag = (PFNGLEDGEFLAGPROC)load("glEdgeFlag"); + glad_glEdgeFlagv = (PFNGLEDGEFLAGVPROC)load("glEdgeFlagv"); + glad_glEnd = (PFNGLENDPROC)load("glEnd"); + glad_glIndexd = (PFNGLINDEXDPROC)load("glIndexd"); + glad_glIndexdv = (PFNGLINDEXDVPROC)load("glIndexdv"); + glad_glIndexf = (PFNGLINDEXFPROC)load("glIndexf"); + glad_glIndexfv = (PFNGLINDEXFVPROC)load("glIndexfv"); + glad_glIndexi = (PFNGLINDEXIPROC)load("glIndexi"); + glad_glIndexiv = (PFNGLINDEXIVPROC)load("glIndexiv"); + glad_glIndexs = (PFNGLINDEXSPROC)load("glIndexs"); + glad_glIndexsv = (PFNGLINDEXSVPROC)load("glIndexsv"); + glad_glNormal3b = (PFNGLNORMAL3BPROC)load("glNormal3b"); + glad_glNormal3bv = (PFNGLNORMAL3BVPROC)load("glNormal3bv"); + glad_glNormal3d = (PFNGLNORMAL3DPROC)load("glNormal3d"); + glad_glNormal3dv = (PFNGLNORMAL3DVPROC)load("glNormal3dv"); + glad_glNormal3f = (PFNGLNORMAL3FPROC)load("glNormal3f"); + glad_glNormal3fv = (PFNGLNORMAL3FVPROC)load("glNormal3fv"); + glad_glNormal3i = (PFNGLNORMAL3IPROC)load("glNormal3i"); + glad_glNormal3iv = (PFNGLNORMAL3IVPROC)load("glNormal3iv"); + glad_glNormal3s = (PFNGLNORMAL3SPROC)load("glNormal3s"); + glad_glNormal3sv = (PFNGLNORMAL3SVPROC)load("glNormal3sv"); + glad_glRasterPos2d = (PFNGLRASTERPOS2DPROC)load("glRasterPos2d"); + glad_glRasterPos2dv = (PFNGLRASTERPOS2DVPROC)load("glRasterPos2dv"); + glad_glRasterPos2f = (PFNGLRASTERPOS2FPROC)load("glRasterPos2f"); + glad_glRasterPos2fv = (PFNGLRASTERPOS2FVPROC)load("glRasterPos2fv"); + glad_glRasterPos2i = (PFNGLRASTERPOS2IPROC)load("glRasterPos2i"); + glad_glRasterPos2iv = (PFNGLRASTERPOS2IVPROC)load("glRasterPos2iv"); + glad_glRasterPos2s = (PFNGLRASTERPOS2SPROC)load("glRasterPos2s"); + glad_glRasterPos2sv = (PFNGLRASTERPOS2SVPROC)load("glRasterPos2sv"); + glad_glRasterPos3d = (PFNGLRASTERPOS3DPROC)load("glRasterPos3d"); + glad_glRasterPos3dv = (PFNGLRASTERPOS3DVPROC)load("glRasterPos3dv"); + glad_glRasterPos3f = (PFNGLRASTERPOS3FPROC)load("glRasterPos3f"); + glad_glRasterPos3fv = (PFNGLRASTERPOS3FVPROC)load("glRasterPos3fv"); + glad_glRasterPos3i = (PFNGLRASTERPOS3IPROC)load("glRasterPos3i"); + glad_glRasterPos3iv = (PFNGLRASTERPOS3IVPROC)load("glRasterPos3iv"); + glad_glRasterPos3s = (PFNGLRASTERPOS3SPROC)load("glRasterPos3s"); + glad_glRasterPos3sv = (PFNGLRASTERPOS3SVPROC)load("glRasterPos3sv"); + glad_glRasterPos4d = (PFNGLRASTERPOS4DPROC)load("glRasterPos4d"); + glad_glRasterPos4dv = (PFNGLRASTERPOS4DVPROC)load("glRasterPos4dv"); + glad_glRasterPos4f = (PFNGLRASTERPOS4FPROC)load("glRasterPos4f"); + glad_glRasterPos4fv = (PFNGLRASTERPOS4FVPROC)load("glRasterPos4fv"); + glad_glRasterPos4i = (PFNGLRASTERPOS4IPROC)load("glRasterPos4i"); + glad_glRasterPos4iv = (PFNGLRASTERPOS4IVPROC)load("glRasterPos4iv"); + glad_glRasterPos4s = (PFNGLRASTERPOS4SPROC)load("glRasterPos4s"); + glad_glRasterPos4sv = (PFNGLRASTERPOS4SVPROC)load("glRasterPos4sv"); + glad_glRectd = (PFNGLRECTDPROC)load("glRectd"); + glad_glRectdv = (PFNGLRECTDVPROC)load("glRectdv"); + glad_glRectf = (PFNGLRECTFPROC)load("glRectf"); + glad_glRectfv = (PFNGLRECTFVPROC)load("glRectfv"); + glad_glRecti = (PFNGLRECTIPROC)load("glRecti"); + glad_glRectiv = (PFNGLRECTIVPROC)load("glRectiv"); + glad_glRects = (PFNGLRECTSPROC)load("glRects"); + glad_glRectsv = (PFNGLRECTSVPROC)load("glRectsv"); + glad_glTexCoord1d = (PFNGLTEXCOORD1DPROC)load("glTexCoord1d"); + glad_glTexCoord1dv = (PFNGLTEXCOORD1DVPROC)load("glTexCoord1dv"); + glad_glTexCoord1f = (PFNGLTEXCOORD1FPROC)load("glTexCoord1f"); + glad_glTexCoord1fv = (PFNGLTEXCOORD1FVPROC)load("glTexCoord1fv"); + glad_glTexCoord1i = (PFNGLTEXCOORD1IPROC)load("glTexCoord1i"); + glad_glTexCoord1iv = (PFNGLTEXCOORD1IVPROC)load("glTexCoord1iv"); + glad_glTexCoord1s = (PFNGLTEXCOORD1SPROC)load("glTexCoord1s"); + glad_glTexCoord1sv = (PFNGLTEXCOORD1SVPROC)load("glTexCoord1sv"); + glad_glTexCoord2d = (PFNGLTEXCOORD2DPROC)load("glTexCoord2d"); + glad_glTexCoord2dv = (PFNGLTEXCOORD2DVPROC)load("glTexCoord2dv"); + glad_glTexCoord2f = (PFNGLTEXCOORD2FPROC)load("glTexCoord2f"); + glad_glTexCoord2fv = (PFNGLTEXCOORD2FVPROC)load("glTexCoord2fv"); + glad_glTexCoord2i = (PFNGLTEXCOORD2IPROC)load("glTexCoord2i"); + glad_glTexCoord2iv = (PFNGLTEXCOORD2IVPROC)load("glTexCoord2iv"); + glad_glTexCoord2s = (PFNGLTEXCOORD2SPROC)load("glTexCoord2s"); + glad_glTexCoord2sv = (PFNGLTEXCOORD2SVPROC)load("glTexCoord2sv"); + glad_glTexCoord3d = (PFNGLTEXCOORD3DPROC)load("glTexCoord3d"); + glad_glTexCoord3dv = (PFNGLTEXCOORD3DVPROC)load("glTexCoord3dv"); + glad_glTexCoord3f = (PFNGLTEXCOORD3FPROC)load("glTexCoord3f"); + glad_glTexCoord3fv = (PFNGLTEXCOORD3FVPROC)load("glTexCoord3fv"); + glad_glTexCoord3i = (PFNGLTEXCOORD3IPROC)load("glTexCoord3i"); + glad_glTexCoord3iv = (PFNGLTEXCOORD3IVPROC)load("glTexCoord3iv"); + glad_glTexCoord3s = (PFNGLTEXCOORD3SPROC)load("glTexCoord3s"); + glad_glTexCoord3sv = (PFNGLTEXCOORD3SVPROC)load("glTexCoord3sv"); + glad_glTexCoord4d = (PFNGLTEXCOORD4DPROC)load("glTexCoord4d"); + glad_glTexCoord4dv = (PFNGLTEXCOORD4DVPROC)load("glTexCoord4dv"); + glad_glTexCoord4f = (PFNGLTEXCOORD4FPROC)load("glTexCoord4f"); + glad_glTexCoord4fv = (PFNGLTEXCOORD4FVPROC)load("glTexCoord4fv"); + glad_glTexCoord4i = (PFNGLTEXCOORD4IPROC)load("glTexCoord4i"); + glad_glTexCoord4iv = (PFNGLTEXCOORD4IVPROC)load("glTexCoord4iv"); + glad_glTexCoord4s = (PFNGLTEXCOORD4SPROC)load("glTexCoord4s"); + glad_glTexCoord4sv = (PFNGLTEXCOORD4SVPROC)load("glTexCoord4sv"); + glad_glVertex2d = (PFNGLVERTEX2DPROC)load("glVertex2d"); + glad_glVertex2dv = (PFNGLVERTEX2DVPROC)load("glVertex2dv"); + glad_glVertex2f = (PFNGLVERTEX2FPROC)load("glVertex2f"); + glad_glVertex2fv = (PFNGLVERTEX2FVPROC)load("glVertex2fv"); + glad_glVertex2i = (PFNGLVERTEX2IPROC)load("glVertex2i"); + glad_glVertex2iv = (PFNGLVERTEX2IVPROC)load("glVertex2iv"); + glad_glVertex2s = (PFNGLVERTEX2SPROC)load("glVertex2s"); + glad_glVertex2sv = (PFNGLVERTEX2SVPROC)load("glVertex2sv"); + glad_glVertex3d = (PFNGLVERTEX3DPROC)load("glVertex3d"); + glad_glVertex3dv = (PFNGLVERTEX3DVPROC)load("glVertex3dv"); + glad_glVertex3f = (PFNGLVERTEX3FPROC)load("glVertex3f"); + glad_glVertex3fv = (PFNGLVERTEX3FVPROC)load("glVertex3fv"); + glad_glVertex3i = (PFNGLVERTEX3IPROC)load("glVertex3i"); + glad_glVertex3iv = (PFNGLVERTEX3IVPROC)load("glVertex3iv"); + glad_glVertex3s = (PFNGLVERTEX3SPROC)load("glVertex3s"); + glad_glVertex3sv = (PFNGLVERTEX3SVPROC)load("glVertex3sv"); + glad_glVertex4d = (PFNGLVERTEX4DPROC)load("glVertex4d"); + glad_glVertex4dv = (PFNGLVERTEX4DVPROC)load("glVertex4dv"); + glad_glVertex4f = (PFNGLVERTEX4FPROC)load("glVertex4f"); + glad_glVertex4fv = (PFNGLVERTEX4FVPROC)load("glVertex4fv"); + glad_glVertex4i = (PFNGLVERTEX4IPROC)load("glVertex4i"); + glad_glVertex4iv = (PFNGLVERTEX4IVPROC)load("glVertex4iv"); + glad_glVertex4s = (PFNGLVERTEX4SPROC)load("glVertex4s"); + glad_glVertex4sv = (PFNGLVERTEX4SVPROC)load("glVertex4sv"); + glad_glClipPlane = (PFNGLCLIPPLANEPROC)load("glClipPlane"); + glad_glColorMaterial = (PFNGLCOLORMATERIALPROC)load("glColorMaterial"); + glad_glFogf = (PFNGLFOGFPROC)load("glFogf"); + glad_glFogfv = (PFNGLFOGFVPROC)load("glFogfv"); + glad_glFogi = (PFNGLFOGIPROC)load("glFogi"); + glad_glFogiv = (PFNGLFOGIVPROC)load("glFogiv"); + glad_glLightf = (PFNGLLIGHTFPROC)load("glLightf"); + glad_glLightfv = (PFNGLLIGHTFVPROC)load("glLightfv"); + glad_glLighti = (PFNGLLIGHTIPROC)load("glLighti"); + glad_glLightiv = (PFNGLLIGHTIVPROC)load("glLightiv"); + glad_glLightModelf = (PFNGLLIGHTMODELFPROC)load("glLightModelf"); + glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC)load("glLightModelfv"); + glad_glLightModeli = (PFNGLLIGHTMODELIPROC)load("glLightModeli"); + glad_glLightModeliv = (PFNGLLIGHTMODELIVPROC)load("glLightModeliv"); + glad_glLineStipple = (PFNGLLINESTIPPLEPROC)load("glLineStipple"); + glad_glMaterialf = (PFNGLMATERIALFPROC)load("glMaterialf"); + glad_glMaterialfv = (PFNGLMATERIALFVPROC)load("glMaterialfv"); + glad_glMateriali = (PFNGLMATERIALIPROC)load("glMateriali"); + glad_glMaterialiv = (PFNGLMATERIALIVPROC)load("glMaterialiv"); + glad_glPolygonStipple = (PFNGLPOLYGONSTIPPLEPROC)load("glPolygonStipple"); + glad_glShadeModel = (PFNGLSHADEMODELPROC)load("glShadeModel"); + glad_glTexEnvf = (PFNGLTEXENVFPROC)load("glTexEnvf"); + glad_glTexEnvfv = (PFNGLTEXENVFVPROC)load("glTexEnvfv"); + glad_glTexEnvi = (PFNGLTEXENVIPROC)load("glTexEnvi"); + glad_glTexEnviv = (PFNGLTEXENVIVPROC)load("glTexEnviv"); + glad_glTexGend = (PFNGLTEXGENDPROC)load("glTexGend"); + glad_glTexGendv = (PFNGLTEXGENDVPROC)load("glTexGendv"); + glad_glTexGenf = (PFNGLTEXGENFPROC)load("glTexGenf"); + glad_glTexGenfv = (PFNGLTEXGENFVPROC)load("glTexGenfv"); + glad_glTexGeni = (PFNGLTEXGENIPROC)load("glTexGeni"); + glad_glTexGeniv = (PFNGLTEXGENIVPROC)load("glTexGeniv"); + glad_glFeedbackBuffer = (PFNGLFEEDBACKBUFFERPROC)load("glFeedbackBuffer"); + glad_glSelectBuffer = (PFNGLSELECTBUFFERPROC)load("glSelectBuffer"); + glad_glRenderMode = (PFNGLRENDERMODEPROC)load("glRenderMode"); + glad_glInitNames = (PFNGLINITNAMESPROC)load("glInitNames"); + glad_glLoadName = (PFNGLLOADNAMEPROC)load("glLoadName"); + glad_glPassThrough = (PFNGLPASSTHROUGHPROC)load("glPassThrough"); + glad_glPopName = (PFNGLPOPNAMEPROC)load("glPopName"); + glad_glPushName = (PFNGLPUSHNAMEPROC)load("glPushName"); + glad_glClearAccum = (PFNGLCLEARACCUMPROC)load("glClearAccum"); + glad_glClearIndex = (PFNGLCLEARINDEXPROC)load("glClearIndex"); + glad_glIndexMask = (PFNGLINDEXMASKPROC)load("glIndexMask"); + glad_glAccum = (PFNGLACCUMPROC)load("glAccum"); + glad_glPopAttrib = (PFNGLPOPATTRIBPROC)load("glPopAttrib"); + glad_glPushAttrib = (PFNGLPUSHATTRIBPROC)load("glPushAttrib"); + glad_glMap1d = (PFNGLMAP1DPROC)load("glMap1d"); + glad_glMap1f = (PFNGLMAP1FPROC)load("glMap1f"); + glad_glMap2d = (PFNGLMAP2DPROC)load("glMap2d"); + glad_glMap2f = (PFNGLMAP2FPROC)load("glMap2f"); + glad_glMapGrid1d = (PFNGLMAPGRID1DPROC)load("glMapGrid1d"); + glad_glMapGrid1f = (PFNGLMAPGRID1FPROC)load("glMapGrid1f"); + glad_glMapGrid2d = (PFNGLMAPGRID2DPROC)load("glMapGrid2d"); + glad_glMapGrid2f = (PFNGLMAPGRID2FPROC)load("glMapGrid2f"); + glad_glEvalCoord1d = (PFNGLEVALCOORD1DPROC)load("glEvalCoord1d"); + glad_glEvalCoord1dv = (PFNGLEVALCOORD1DVPROC)load("glEvalCoord1dv"); + glad_glEvalCoord1f = (PFNGLEVALCOORD1FPROC)load("glEvalCoord1f"); + glad_glEvalCoord1fv = (PFNGLEVALCOORD1FVPROC)load("glEvalCoord1fv"); + glad_glEvalCoord2d = (PFNGLEVALCOORD2DPROC)load("glEvalCoord2d"); + glad_glEvalCoord2dv = (PFNGLEVALCOORD2DVPROC)load("glEvalCoord2dv"); + glad_glEvalCoord2f = (PFNGLEVALCOORD2FPROC)load("glEvalCoord2f"); + glad_glEvalCoord2fv = (PFNGLEVALCOORD2FVPROC)load("glEvalCoord2fv"); + glad_glEvalMesh1 = (PFNGLEVALMESH1PROC)load("glEvalMesh1"); + glad_glEvalPoint1 = (PFNGLEVALPOINT1PROC)load("glEvalPoint1"); + glad_glEvalMesh2 = (PFNGLEVALMESH2PROC)load("glEvalMesh2"); + glad_glEvalPoint2 = (PFNGLEVALPOINT2PROC)load("glEvalPoint2"); + glad_glAlphaFunc = (PFNGLALPHAFUNCPROC)load("glAlphaFunc"); + glad_glPixelZoom = (PFNGLPIXELZOOMPROC)load("glPixelZoom"); + glad_glPixelTransferf = (PFNGLPIXELTRANSFERFPROC)load("glPixelTransferf"); + glad_glPixelTransferi = (PFNGLPIXELTRANSFERIPROC)load("glPixelTransferi"); + glad_glPixelMapfv = (PFNGLPIXELMAPFVPROC)load("glPixelMapfv"); + glad_glPixelMapuiv = (PFNGLPIXELMAPUIVPROC)load("glPixelMapuiv"); + glad_glPixelMapusv = (PFNGLPIXELMAPUSVPROC)load("glPixelMapusv"); + glad_glCopyPixels = (PFNGLCOPYPIXELSPROC)load("glCopyPixels"); + glad_glDrawPixels = (PFNGLDRAWPIXELSPROC)load("glDrawPixels"); + glad_glGetClipPlane = (PFNGLGETCLIPPLANEPROC)load("glGetClipPlane"); + glad_glGetLightfv = (PFNGLGETLIGHTFVPROC)load("glGetLightfv"); + glad_glGetLightiv = (PFNGLGETLIGHTIVPROC)load("glGetLightiv"); + glad_glGetMapdv = (PFNGLGETMAPDVPROC)load("glGetMapdv"); + glad_glGetMapfv = (PFNGLGETMAPFVPROC)load("glGetMapfv"); + glad_glGetMapiv = (PFNGLGETMAPIVPROC)load("glGetMapiv"); + glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC)load("glGetMaterialfv"); + glad_glGetMaterialiv = (PFNGLGETMATERIALIVPROC)load("glGetMaterialiv"); + glad_glGetPixelMapfv = (PFNGLGETPIXELMAPFVPROC)load("glGetPixelMapfv"); + glad_glGetPixelMapuiv = (PFNGLGETPIXELMAPUIVPROC)load("glGetPixelMapuiv"); + glad_glGetPixelMapusv = (PFNGLGETPIXELMAPUSVPROC)load("glGetPixelMapusv"); + glad_glGetPolygonStipple = (PFNGLGETPOLYGONSTIPPLEPROC)load("glGetPolygonStipple"); + glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC)load("glGetTexEnvfv"); + glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC)load("glGetTexEnviv"); + glad_glGetTexGendv = (PFNGLGETTEXGENDVPROC)load("glGetTexGendv"); + glad_glGetTexGenfv = (PFNGLGETTEXGENFVPROC)load("glGetTexGenfv"); + glad_glGetTexGeniv = (PFNGLGETTEXGENIVPROC)load("glGetTexGeniv"); + glad_glIsList = (PFNGLISLISTPROC)load("glIsList"); + glad_glFrustum = (PFNGLFRUSTUMPROC)load("glFrustum"); + glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC)load("glLoadIdentity"); + glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC)load("glLoadMatrixf"); + glad_glLoadMatrixd = (PFNGLLOADMATRIXDPROC)load("glLoadMatrixd"); + glad_glMatrixMode = (PFNGLMATRIXMODEPROC)load("glMatrixMode"); + glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC)load("glMultMatrixf"); + glad_glMultMatrixd = (PFNGLMULTMATRIXDPROC)load("glMultMatrixd"); + glad_glOrtho = (PFNGLORTHOPROC)load("glOrtho"); + glad_glPopMatrix = (PFNGLPOPMATRIXPROC)load("glPopMatrix"); + glad_glPushMatrix = (PFNGLPUSHMATRIXPROC)load("glPushMatrix"); + glad_glRotated = (PFNGLROTATEDPROC)load("glRotated"); + glad_glRotatef = (PFNGLROTATEFPROC)load("glRotatef"); + glad_glScaled = (PFNGLSCALEDPROC)load("glScaled"); + glad_glScalef = (PFNGLSCALEFPROC)load("glScalef"); + glad_glTranslated = (PFNGLTRANSLATEDPROC)load("glTranslated"); + glad_glTranslatef = (PFNGLTRANSLATEFPROC)load("glTranslatef"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); + glad_glArrayElement = (PFNGLARRAYELEMENTPROC)load("glArrayElement"); + glad_glColorPointer = (PFNGLCOLORPOINTERPROC)load("glColorPointer"); + glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC)load("glDisableClientState"); + glad_glEdgeFlagPointer = (PFNGLEDGEFLAGPOINTERPROC)load("glEdgeFlagPointer"); + glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC)load("glEnableClientState"); + glad_glIndexPointer = (PFNGLINDEXPOINTERPROC)load("glIndexPointer"); + glad_glInterleavedArrays = (PFNGLINTERLEAVEDARRAYSPROC)load("glInterleavedArrays"); + glad_glNormalPointer = (PFNGLNORMALPOINTERPROC)load("glNormalPointer"); + glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC)load("glTexCoordPointer"); + glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC)load("glVertexPointer"); + glad_glAreTexturesResident = (PFNGLARETEXTURESRESIDENTPROC)load("glAreTexturesResident"); + glad_glPrioritizeTextures = (PFNGLPRIORITIZETEXTURESPROC)load("glPrioritizeTextures"); + glad_glIndexub = (PFNGLINDEXUBPROC)load("glIndexub"); + glad_glIndexubv = (PFNGLINDEXUBVPROC)load("glIndexubv"); + glad_glPopClientAttrib = (PFNGLPOPCLIENTATTRIBPROC)load("glPopClientAttrib"); + glad_glPushClientAttrib = (PFNGLPUSHCLIENTATTRIBPROC)load("glPushClientAttrib"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); + glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)load("glClientActiveTexture"); + glad_glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)load("glMultiTexCoord1d"); + glad_glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)load("glMultiTexCoord1dv"); + glad_glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)load("glMultiTexCoord1f"); + glad_glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)load("glMultiTexCoord1fv"); + glad_glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)load("glMultiTexCoord1i"); + glad_glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)load("glMultiTexCoord1iv"); + glad_glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)load("glMultiTexCoord1s"); + glad_glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)load("glMultiTexCoord1sv"); + glad_glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)load("glMultiTexCoord2d"); + glad_glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)load("glMultiTexCoord2dv"); + glad_glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)load("glMultiTexCoord2f"); + glad_glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)load("glMultiTexCoord2fv"); + glad_glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)load("glMultiTexCoord2i"); + glad_glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)load("glMultiTexCoord2iv"); + glad_glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)load("glMultiTexCoord2s"); + glad_glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)load("glMultiTexCoord2sv"); + glad_glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)load("glMultiTexCoord3d"); + glad_glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)load("glMultiTexCoord3dv"); + glad_glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)load("glMultiTexCoord3f"); + glad_glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)load("glMultiTexCoord3fv"); + glad_glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)load("glMultiTexCoord3i"); + glad_glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)load("glMultiTexCoord3iv"); + glad_glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)load("glMultiTexCoord3s"); + glad_glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)load("glMultiTexCoord3sv"); + glad_glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)load("glMultiTexCoord4d"); + glad_glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)load("glMultiTexCoord4dv"); + glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)load("glMultiTexCoord4f"); + glad_glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)load("glMultiTexCoord4fv"); + glad_glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)load("glMultiTexCoord4i"); + glad_glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)load("glMultiTexCoord4iv"); + glad_glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)load("glMultiTexCoord4s"); + glad_glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)load("glMultiTexCoord4sv"); + glad_glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)load("glLoadTransposeMatrixf"); + glad_glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)load("glLoadTransposeMatrixd"); + glad_glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)load("glMultTransposeMatrixf"); + glad_glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)load("glMultTransposeMatrixd"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glFogCoordf = (PFNGLFOGCOORDFPROC)load("glFogCoordf"); + glad_glFogCoordfv = (PFNGLFOGCOORDFVPROC)load("glFogCoordfv"); + glad_glFogCoordd = (PFNGLFOGCOORDDPROC)load("glFogCoordd"); + glad_glFogCoorddv = (PFNGLFOGCOORDDVPROC)load("glFogCoorddv"); + glad_glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)load("glFogCoordPointer"); + glad_glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)load("glSecondaryColor3b"); + glad_glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)load("glSecondaryColor3bv"); + glad_glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)load("glSecondaryColor3d"); + glad_glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)load("glSecondaryColor3dv"); + glad_glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)load("glSecondaryColor3f"); + glad_glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)load("glSecondaryColor3fv"); + glad_glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)load("glSecondaryColor3i"); + glad_glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)load("glSecondaryColor3iv"); + glad_glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)load("glSecondaryColor3s"); + glad_glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)load("glSecondaryColor3sv"); + glad_glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)load("glSecondaryColor3ub"); + glad_glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)load("glSecondaryColor3ubv"); + glad_glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)load("glSecondaryColor3ui"); + glad_glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)load("glSecondaryColor3uiv"); + glad_glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)load("glSecondaryColor3us"); + glad_glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)load("glSecondaryColor3usv"); + glad_glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)load("glSecondaryColorPointer"); + glad_glWindowPos2d = (PFNGLWINDOWPOS2DPROC)load("glWindowPos2d"); + glad_glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)load("glWindowPos2dv"); + glad_glWindowPos2f = (PFNGLWINDOWPOS2FPROC)load("glWindowPos2f"); + glad_glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)load("glWindowPos2fv"); + glad_glWindowPos2i = (PFNGLWINDOWPOS2IPROC)load("glWindowPos2i"); + glad_glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)load("glWindowPos2iv"); + glad_glWindowPos2s = (PFNGLWINDOWPOS2SPROC)load("glWindowPos2s"); + glad_glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)load("glWindowPos2sv"); + glad_glWindowPos3d = (PFNGLWINDOWPOS3DPROC)load("glWindowPos3d"); + glad_glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)load("glWindowPos3dv"); + glad_glWindowPos3f = (PFNGLWINDOWPOS3FPROC)load("glWindowPos3f"); + glad_glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)load("glWindowPos3fv"); + glad_glWindowPos3i = (PFNGLWINDOWPOS3IPROC)load("glWindowPos3i"); + glad_glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)load("glWindowPos3iv"); + glad_glWindowPos3s = (PFNGLWINDOWPOS3SPROC)load("glWindowPos3s"); + glad_glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)load("glWindowPos3sv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + if (GLVersion.major > 2 || (GLVersion.major >= 2 && GLVersion.minor >= 1)) { + max_loaded_major = 2; + max_loaded_minor = 1; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/ffi/glad.h b/ffi/glad.h new file mode 100644 index 0000000..4fa9465 --- /dev/null +++ b/ffi/glad.h @@ -0,0 +1,2749 @@ +/* + + OpenGL loader generated by glad 0.1.27 on Tue Sep 4 23:27:29 2018. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=2.1 + Profile: compatibility + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + + Commandline: + --profile="compatibility" --api="gl=2.1" --generator="c" --spec="gl" --extensions="" + Online: + http://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gl%3D2.1 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN 1 +#endif +#ifndef NOMINMAX +#define NOMINMAX 1 +#endif +#include +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +#include "khrplatform.h" +#ifndef GLEXT_64_TYPES_DEFINED +/* This code block is duplicated in glxext.h, so must be protected */ +#define GLEXT_64_TYPES_DEFINED +/* Define int32_t, int64_t, and uint64_t types for UST/MSC */ +/* (as used in the GL_EXT_timer_query extension). */ +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#include +#elif defined(__sun__) || defined(__digital__) +#include +#if defined(__STDC__) +#if defined(__arch64__) || defined(_LP64) +typedef long int int64_t; +typedef unsigned long int uint64_t; +#else +typedef long long int int64_t; +typedef unsigned long long int uint64_t; +#endif /* __arch64__ */ +#endif /* __STDC__ */ +#elif defined( __VMS ) || defined(__sgi) +#include +#elif defined(__SCO__) || defined(__USLC__) +#include +#elif defined(__UNIXOS2__) || defined(__SOL64__) +typedef long int int32_t; +typedef long long int int64_t; +typedef unsigned long long int uint64_t; +#elif defined(_WIN32) && defined(__GNUC__) +#include +#elif defined(_WIN32) +typedef __int32 int32_t; +typedef __int64 int64_t; +typedef unsigned __int64 uint64_t; +#else +/* Fallback if nothing above works */ +#include +#endif +#endif +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef signed char GLbyte; +typedef short GLshort; +typedef int GLint; +typedef int GLclampx; +typedef unsigned char GLubyte; +typedef unsigned short GLushort; +typedef unsigned int GLuint; +typedef int GLsizei; +typedef float GLfloat; +typedef float GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef unsigned short GLhalfARB; +typedef unsigned short GLhalf; +typedef GLint GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_ssize_t GLsizeiptr; +typedef int64_t GLint64; +typedef uint64_t GLuint64; +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) +typedef long GLintptrARB; +#else +typedef ptrdiff_t GLintptrARB; +#endif +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) +typedef long GLsizeiptrARB; +#else +typedef ptrdiff_t GLsizeiptrARB; +#endif +typedef int64_t GLint64EXT; +typedef uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_QUADS 0x0007 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_STACK_OVERFLOW 0x0503 +#define GL_STACK_UNDERFLOW 0x0504 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_CURRENT_BIT 0x00000001 +#define GL_POINT_BIT 0x00000002 +#define GL_LINE_BIT 0x00000004 +#define GL_POLYGON_BIT 0x00000008 +#define GL_POLYGON_STIPPLE_BIT 0x00000010 +#define GL_PIXEL_MODE_BIT 0x00000020 +#define GL_LIGHTING_BIT 0x00000040 +#define GL_FOG_BIT 0x00000080 +#define GL_ACCUM_BUFFER_BIT 0x00000200 +#define GL_VIEWPORT_BIT 0x00000800 +#define GL_TRANSFORM_BIT 0x00001000 +#define GL_ENABLE_BIT 0x00002000 +#define GL_HINT_BIT 0x00008000 +#define GL_EVAL_BIT 0x00010000 +#define GL_LIST_BIT 0x00020000 +#define GL_TEXTURE_BIT 0x00040000 +#define GL_SCISSOR_BIT 0x00080000 +#define GL_ALL_ATTRIB_BITS 0xFFFFFFFF +#define GL_QUAD_STRIP 0x0008 +#define GL_POLYGON 0x0009 +#define GL_ACCUM 0x0100 +#define GL_LOAD 0x0101 +#define GL_RETURN 0x0102 +#define GL_MULT 0x0103 +#define GL_ADD 0x0104 +#define GL_AUX0 0x0409 +#define GL_AUX1 0x040A +#define GL_AUX2 0x040B +#define GL_AUX3 0x040C +#define GL_2D 0x0600 +#define GL_3D 0x0601 +#define GL_3D_COLOR 0x0602 +#define GL_3D_COLOR_TEXTURE 0x0603 +#define GL_4D_COLOR_TEXTURE 0x0604 +#define GL_PASS_THROUGH_TOKEN 0x0700 +#define GL_POINT_TOKEN 0x0701 +#define GL_LINE_TOKEN 0x0702 +#define GL_POLYGON_TOKEN 0x0703 +#define GL_BITMAP_TOKEN 0x0704 +#define GL_DRAW_PIXEL_TOKEN 0x0705 +#define GL_COPY_PIXEL_TOKEN 0x0706 +#define GL_LINE_RESET_TOKEN 0x0707 +#define GL_EXP 0x0800 +#define GL_EXP2 0x0801 +#define GL_COEFF 0x0A00 +#define GL_ORDER 0x0A01 +#define GL_DOMAIN 0x0A02 +#define GL_PIXEL_MAP_I_TO_I 0x0C70 +#define GL_PIXEL_MAP_S_TO_S 0x0C71 +#define GL_PIXEL_MAP_I_TO_R 0x0C72 +#define GL_PIXEL_MAP_I_TO_G 0x0C73 +#define GL_PIXEL_MAP_I_TO_B 0x0C74 +#define GL_PIXEL_MAP_I_TO_A 0x0C75 +#define GL_PIXEL_MAP_R_TO_R 0x0C76 +#define GL_PIXEL_MAP_G_TO_G 0x0C77 +#define GL_PIXEL_MAP_B_TO_B 0x0C78 +#define GL_PIXEL_MAP_A_TO_A 0x0C79 +#define GL_CURRENT_COLOR 0x0B00 +#define GL_CURRENT_INDEX 0x0B01 +#define GL_CURRENT_NORMAL 0x0B02 +#define GL_CURRENT_TEXTURE_COORDS 0x0B03 +#define GL_CURRENT_RASTER_COLOR 0x0B04 +#define GL_CURRENT_RASTER_INDEX 0x0B05 +#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06 +#define GL_CURRENT_RASTER_POSITION 0x0B07 +#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08 +#define GL_CURRENT_RASTER_DISTANCE 0x0B09 +#define GL_POINT_SMOOTH 0x0B10 +#define GL_LINE_STIPPLE 0x0B24 +#define GL_LINE_STIPPLE_PATTERN 0x0B25 +#define GL_LINE_STIPPLE_REPEAT 0x0B26 +#define GL_LIST_MODE 0x0B30 +#define GL_MAX_LIST_NESTING 0x0B31 +#define GL_LIST_BASE 0x0B32 +#define GL_LIST_INDEX 0x0B33 +#define GL_POLYGON_STIPPLE 0x0B42 +#define GL_EDGE_FLAG 0x0B43 +#define GL_LIGHTING 0x0B50 +#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51 +#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52 +#define GL_LIGHT_MODEL_AMBIENT 0x0B53 +#define GL_SHADE_MODEL 0x0B54 +#define GL_COLOR_MATERIAL_FACE 0x0B55 +#define GL_COLOR_MATERIAL_PARAMETER 0x0B56 +#define GL_COLOR_MATERIAL 0x0B57 +#define GL_FOG 0x0B60 +#define GL_FOG_INDEX 0x0B61 +#define GL_FOG_DENSITY 0x0B62 +#define GL_FOG_START 0x0B63 +#define GL_FOG_END 0x0B64 +#define GL_FOG_MODE 0x0B65 +#define GL_FOG_COLOR 0x0B66 +#define GL_ACCUM_CLEAR_VALUE 0x0B80 +#define GL_MATRIX_MODE 0x0BA0 +#define GL_NORMALIZE 0x0BA1 +#define GL_MODELVIEW_STACK_DEPTH 0x0BA3 +#define GL_PROJECTION_STACK_DEPTH 0x0BA4 +#define GL_TEXTURE_STACK_DEPTH 0x0BA5 +#define GL_MODELVIEW_MATRIX 0x0BA6 +#define GL_PROJECTION_MATRIX 0x0BA7 +#define GL_TEXTURE_MATRIX 0x0BA8 +#define GL_ATTRIB_STACK_DEPTH 0x0BB0 +#define GL_ALPHA_TEST 0x0BC0 +#define GL_ALPHA_TEST_FUNC 0x0BC1 +#define GL_ALPHA_TEST_REF 0x0BC2 +#define GL_LOGIC_OP 0x0BF1 +#define GL_AUX_BUFFERS 0x0C00 +#define GL_INDEX_CLEAR_VALUE 0x0C20 +#define GL_INDEX_WRITEMASK 0x0C21 +#define GL_INDEX_MODE 0x0C30 +#define GL_RGBA_MODE 0x0C31 +#define GL_RENDER_MODE 0x0C40 +#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50 +#define GL_POINT_SMOOTH_HINT 0x0C51 +#define GL_FOG_HINT 0x0C54 +#define GL_TEXTURE_GEN_S 0x0C60 +#define GL_TEXTURE_GEN_T 0x0C61 +#define GL_TEXTURE_GEN_R 0x0C62 +#define GL_TEXTURE_GEN_Q 0x0C63 +#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0 +#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1 +#define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2 +#define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3 +#define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4 +#define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5 +#define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6 +#define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7 +#define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8 +#define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9 +#define GL_MAP_COLOR 0x0D10 +#define GL_MAP_STENCIL 0x0D11 +#define GL_INDEX_SHIFT 0x0D12 +#define GL_INDEX_OFFSET 0x0D13 +#define GL_RED_SCALE 0x0D14 +#define GL_RED_BIAS 0x0D15 +#define GL_ZOOM_X 0x0D16 +#define GL_ZOOM_Y 0x0D17 +#define GL_GREEN_SCALE 0x0D18 +#define GL_GREEN_BIAS 0x0D19 +#define GL_BLUE_SCALE 0x0D1A +#define GL_BLUE_BIAS 0x0D1B +#define GL_ALPHA_SCALE 0x0D1C +#define GL_ALPHA_BIAS 0x0D1D +#define GL_DEPTH_SCALE 0x0D1E +#define GL_DEPTH_BIAS 0x0D1F +#define GL_MAX_EVAL_ORDER 0x0D30 +#define GL_MAX_LIGHTS 0x0D31 +#define GL_MAX_CLIP_PLANES 0x0D32 +#define GL_MAX_PIXEL_MAP_TABLE 0x0D34 +#define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35 +#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36 +#define GL_MAX_NAME_STACK_DEPTH 0x0D37 +#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38 +#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39 +#define GL_INDEX_BITS 0x0D51 +#define GL_RED_BITS 0x0D52 +#define GL_GREEN_BITS 0x0D53 +#define GL_BLUE_BITS 0x0D54 +#define GL_ALPHA_BITS 0x0D55 +#define GL_DEPTH_BITS 0x0D56 +#define GL_STENCIL_BITS 0x0D57 +#define GL_ACCUM_RED_BITS 0x0D58 +#define GL_ACCUM_GREEN_BITS 0x0D59 +#define GL_ACCUM_BLUE_BITS 0x0D5A +#define GL_ACCUM_ALPHA_BITS 0x0D5B +#define GL_NAME_STACK_DEPTH 0x0D70 +#define GL_AUTO_NORMAL 0x0D80 +#define GL_MAP1_COLOR_4 0x0D90 +#define GL_MAP1_INDEX 0x0D91 +#define GL_MAP1_NORMAL 0x0D92 +#define GL_MAP1_TEXTURE_COORD_1 0x0D93 +#define GL_MAP1_TEXTURE_COORD_2 0x0D94 +#define GL_MAP1_TEXTURE_COORD_3 0x0D95 +#define GL_MAP1_TEXTURE_COORD_4 0x0D96 +#define GL_MAP1_VERTEX_3 0x0D97 +#define GL_MAP1_VERTEX_4 0x0D98 +#define GL_MAP2_COLOR_4 0x0DB0 +#define GL_MAP2_INDEX 0x0DB1 +#define GL_MAP2_NORMAL 0x0DB2 +#define GL_MAP2_TEXTURE_COORD_1 0x0DB3 +#define GL_MAP2_TEXTURE_COORD_2 0x0DB4 +#define GL_MAP2_TEXTURE_COORD_3 0x0DB5 +#define GL_MAP2_TEXTURE_COORD_4 0x0DB6 +#define GL_MAP2_VERTEX_3 0x0DB7 +#define GL_MAP2_VERTEX_4 0x0DB8 +#define GL_MAP1_GRID_DOMAIN 0x0DD0 +#define GL_MAP1_GRID_SEGMENTS 0x0DD1 +#define GL_MAP2_GRID_DOMAIN 0x0DD2 +#define GL_MAP2_GRID_SEGMENTS 0x0DD3 +#define GL_TEXTURE_COMPONENTS 0x1003 +#define GL_TEXTURE_BORDER 0x1005 +#define GL_AMBIENT 0x1200 +#define GL_DIFFUSE 0x1201 +#define GL_SPECULAR 0x1202 +#define GL_POSITION 0x1203 +#define GL_SPOT_DIRECTION 0x1204 +#define GL_SPOT_EXPONENT 0x1205 +#define GL_SPOT_CUTOFF 0x1206 +#define GL_CONSTANT_ATTENUATION 0x1207 +#define GL_LINEAR_ATTENUATION 0x1208 +#define GL_QUADRATIC_ATTENUATION 0x1209 +#define GL_COMPILE 0x1300 +#define GL_COMPILE_AND_EXECUTE 0x1301 +#define GL_2_BYTES 0x1407 +#define GL_3_BYTES 0x1408 +#define GL_4_BYTES 0x1409 +#define GL_EMISSION 0x1600 +#define GL_SHININESS 0x1601 +#define GL_AMBIENT_AND_DIFFUSE 0x1602 +#define GL_COLOR_INDEXES 0x1603 +#define GL_MODELVIEW 0x1700 +#define GL_PROJECTION 0x1701 +#define GL_COLOR_INDEX 0x1900 +#define GL_LUMINANCE 0x1909 +#define GL_LUMINANCE_ALPHA 0x190A +#define GL_BITMAP 0x1A00 +#define GL_RENDER 0x1C00 +#define GL_FEEDBACK 0x1C01 +#define GL_SELECT 0x1C02 +#define GL_FLAT 0x1D00 +#define GL_SMOOTH 0x1D01 +#define GL_S 0x2000 +#define GL_T 0x2001 +#define GL_R 0x2002 +#define GL_Q 0x2003 +#define GL_MODULATE 0x2100 +#define GL_DECAL 0x2101 +#define GL_TEXTURE_ENV_MODE 0x2200 +#define GL_TEXTURE_ENV_COLOR 0x2201 +#define GL_TEXTURE_ENV 0x2300 +#define GL_EYE_LINEAR 0x2400 +#define GL_OBJECT_LINEAR 0x2401 +#define GL_SPHERE_MAP 0x2402 +#define GL_TEXTURE_GEN_MODE 0x2500 +#define GL_OBJECT_PLANE 0x2501 +#define GL_EYE_PLANE 0x2502 +#define GL_CLAMP 0x2900 +#define GL_CLIP_PLANE0 0x3000 +#define GL_CLIP_PLANE1 0x3001 +#define GL_CLIP_PLANE2 0x3002 +#define GL_CLIP_PLANE3 0x3003 +#define GL_CLIP_PLANE4 0x3004 +#define GL_CLIP_PLANE5 0x3005 +#define GL_LIGHT0 0x4000 +#define GL_LIGHT1 0x4001 +#define GL_LIGHT2 0x4002 +#define GL_LIGHT3 0x4003 +#define GL_LIGHT4 0x4004 +#define GL_LIGHT5 0x4005 +#define GL_LIGHT6 0x4006 +#define GL_LIGHT7 0x4007 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_CLIENT_PIXEL_STORE_BIT 0x00000001 +#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002 +#define GL_CLIENT_ALL_ATTRIB_BITS 0xFFFFFFFF +#define GL_VERTEX_ARRAY_POINTER 0x808E +#define GL_NORMAL_ARRAY_POINTER 0x808F +#define GL_COLOR_ARRAY_POINTER 0x8090 +#define GL_INDEX_ARRAY_POINTER 0x8091 +#define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092 +#define GL_EDGE_FLAG_ARRAY_POINTER 0x8093 +#define GL_FEEDBACK_BUFFER_POINTER 0x0DF0 +#define GL_SELECTION_BUFFER_POINTER 0x0DF3 +#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1 +#define GL_INDEX_LOGIC_OP 0x0BF1 +#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B +#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1 +#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2 +#define GL_SELECTION_BUFFER_SIZE 0x0DF4 +#define GL_VERTEX_ARRAY 0x8074 +#define GL_NORMAL_ARRAY 0x8075 +#define GL_COLOR_ARRAY 0x8076 +#define GL_INDEX_ARRAY 0x8077 +#define GL_TEXTURE_COORD_ARRAY 0x8078 +#define GL_EDGE_FLAG_ARRAY 0x8079 +#define GL_VERTEX_ARRAY_SIZE 0x807A +#define GL_VERTEX_ARRAY_TYPE 0x807B +#define GL_VERTEX_ARRAY_STRIDE 0x807C +#define GL_NORMAL_ARRAY_TYPE 0x807E +#define GL_NORMAL_ARRAY_STRIDE 0x807F +#define GL_COLOR_ARRAY_SIZE 0x8081 +#define GL_COLOR_ARRAY_TYPE 0x8082 +#define GL_COLOR_ARRAY_STRIDE 0x8083 +#define GL_INDEX_ARRAY_TYPE 0x8085 +#define GL_INDEX_ARRAY_STRIDE 0x8086 +#define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088 +#define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089 +#define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A +#define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C +#define GL_TEXTURE_LUMINANCE_SIZE 0x8060 +#define GL_TEXTURE_INTENSITY_SIZE 0x8061 +#define GL_TEXTURE_PRIORITY 0x8066 +#define GL_TEXTURE_RESIDENT 0x8067 +#define GL_ALPHA4 0x803B +#define GL_ALPHA8 0x803C +#define GL_ALPHA12 0x803D +#define GL_ALPHA16 0x803E +#define GL_LUMINANCE4 0x803F +#define GL_LUMINANCE8 0x8040 +#define GL_LUMINANCE12 0x8041 +#define GL_LUMINANCE16 0x8042 +#define GL_LUMINANCE4_ALPHA4 0x8043 +#define GL_LUMINANCE6_ALPHA2 0x8044 +#define GL_LUMINANCE8_ALPHA8 0x8045 +#define GL_LUMINANCE12_ALPHA4 0x8046 +#define GL_LUMINANCE12_ALPHA12 0x8047 +#define GL_LUMINANCE16_ALPHA16 0x8048 +#define GL_INTENSITY 0x8049 +#define GL_INTENSITY4 0x804A +#define GL_INTENSITY8 0x804B +#define GL_INTENSITY12 0x804C +#define GL_INTENSITY16 0x804D +#define GL_V2F 0x2A20 +#define GL_V3F 0x2A21 +#define GL_C4UB_V2F 0x2A22 +#define GL_C4UB_V3F 0x2A23 +#define GL_C3F_V3F 0x2A24 +#define GL_N3F_V3F 0x2A25 +#define GL_C4F_N3F_V3F 0x2A26 +#define GL_T2F_V3F 0x2A27 +#define GL_T4F_V4F 0x2A28 +#define GL_T2F_C4UB_V3F 0x2A29 +#define GL_T2F_C3F_V3F 0x2A2A +#define GL_T2F_N3F_V3F 0x2A2B +#define GL_T2F_C4F_N3F_V3F 0x2A2C +#define GL_T4F_C4F_N3F_V4F 0x2A2D +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_RESCALE_NORMAL 0x803A +#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 +#define GL_SINGLE_COLOR 0x81F9 +#define GL_SEPARATE_SPECULAR_COLOR 0x81FA +#define GL_ALIASED_POINT_SIZE_RANGE 0x846D +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 +#define GL_MAX_TEXTURE_UNITS 0x84E2 +#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 +#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 +#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 +#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 +#define GL_MULTISAMPLE_BIT 0x20000000 +#define GL_NORMAL_MAP 0x8511 +#define GL_REFLECTION_MAP 0x8512 +#define GL_COMPRESSED_ALPHA 0x84E9 +#define GL_COMPRESSED_LUMINANCE 0x84EA +#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB +#define GL_COMPRESSED_INTENSITY 0x84EC +#define GL_COMBINE 0x8570 +#define GL_COMBINE_RGB 0x8571 +#define GL_COMBINE_ALPHA 0x8572 +#define GL_SOURCE0_RGB 0x8580 +#define GL_SOURCE1_RGB 0x8581 +#define GL_SOURCE2_RGB 0x8582 +#define GL_SOURCE0_ALPHA 0x8588 +#define GL_SOURCE1_ALPHA 0x8589 +#define GL_SOURCE2_ALPHA 0x858A +#define GL_OPERAND0_RGB 0x8590 +#define GL_OPERAND1_RGB 0x8591 +#define GL_OPERAND2_RGB 0x8592 +#define GL_OPERAND0_ALPHA 0x8598 +#define GL_OPERAND1_ALPHA 0x8599 +#define GL_OPERAND2_ALPHA 0x859A +#define GL_RGB_SCALE 0x8573 +#define GL_ADD_SIGNED 0x8574 +#define GL_INTERPOLATE 0x8575 +#define GL_SUBTRACT 0x84E7 +#define GL_CONSTANT 0x8576 +#define GL_PRIMARY_COLOR 0x8577 +#define GL_PREVIOUS 0x8578 +#define GL_DOT3_RGB 0x86AE +#define GL_DOT3_RGBA 0x86AF +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_POINT_SIZE_MIN 0x8126 +#define GL_POINT_SIZE_MAX 0x8127 +#define GL_POINT_DISTANCE_ATTENUATION 0x8129 +#define GL_GENERATE_MIPMAP 0x8191 +#define GL_GENERATE_MIPMAP_HINT 0x8192 +#define GL_FOG_COORDINATE_SOURCE 0x8450 +#define GL_FOG_COORDINATE 0x8451 +#define GL_FRAGMENT_DEPTH 0x8452 +#define GL_CURRENT_FOG_COORDINATE 0x8453 +#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 +#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 +#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 +#define GL_FOG_COORDINATE_ARRAY 0x8457 +#define GL_COLOR_SUM 0x8458 +#define GL_CURRENT_SECONDARY_COLOR 0x8459 +#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A +#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B +#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C +#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D +#define GL_SECONDARY_COLOR_ARRAY 0x845E +#define GL_TEXTURE_FILTER_CONTROL 0x8500 +#define GL_DEPTH_TEXTURE_MODE 0x884B +#define GL_COMPARE_R_TO_TEXTURE 0x884E +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896 +#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897 +#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898 +#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899 +#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A +#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B +#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C +#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D +#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E +#define GL_FOG_COORD_SRC 0x8450 +#define GL_FOG_COORD 0x8451 +#define GL_CURRENT_FOG_COORD 0x8453 +#define GL_FOG_COORD_ARRAY_TYPE 0x8454 +#define GL_FOG_COORD_ARRAY_STRIDE 0x8455 +#define GL_FOG_COORD_ARRAY_POINTER 0x8456 +#define GL_FOG_COORD_ARRAY 0x8457 +#define GL_FOG_COORD_ARRAY_BUFFER_BINDING 0x889D +#define GL_SRC0_RGB 0x8580 +#define GL_SRC1_RGB 0x8581 +#define GL_SRC2_RGB 0x8582 +#define GL_SRC0_ALPHA 0x8588 +#define GL_SRC2_ALPHA 0x858A +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643 +#define GL_POINT_SPRITE 0x8861 +#define GL_COORD_REPLACE 0x8862 +#define GL_MAX_TEXTURE_COORDS 0x8871 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F +#define GL_SLUMINANCE_ALPHA 0x8C44 +#define GL_SLUMINANCE8_ALPHA8 0x8C45 +#define GL_SLUMINANCE 0x8C46 +#define GL_SLUMINANCE8 0x8C47 +#define GL_COMPRESSED_SLUMINANCE 0x8C4A +#define GL_COMPRESSED_SLUMINANCE_ALPHA 0x8C4B +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +typedef void (APIENTRYP PFNGLNEWLISTPROC)(GLuint list, GLenum mode); +GLAPI PFNGLNEWLISTPROC glad_glNewList; +#define glNewList glad_glNewList +typedef void (APIENTRYP PFNGLENDLISTPROC)(void); +GLAPI PFNGLENDLISTPROC glad_glEndList; +#define glEndList glad_glEndList +typedef void (APIENTRYP PFNGLCALLLISTPROC)(GLuint list); +GLAPI PFNGLCALLLISTPROC glad_glCallList; +#define glCallList glad_glCallList +typedef void (APIENTRYP PFNGLCALLLISTSPROC)(GLsizei n, GLenum type, const void *lists); +GLAPI PFNGLCALLLISTSPROC glad_glCallLists; +#define glCallLists glad_glCallLists +typedef void (APIENTRYP PFNGLDELETELISTSPROC)(GLuint list, GLsizei range); +GLAPI PFNGLDELETELISTSPROC glad_glDeleteLists; +#define glDeleteLists glad_glDeleteLists +typedef GLuint (APIENTRYP PFNGLGENLISTSPROC)(GLsizei range); +GLAPI PFNGLGENLISTSPROC glad_glGenLists; +#define glGenLists glad_glGenLists +typedef void (APIENTRYP PFNGLLISTBASEPROC)(GLuint base); +GLAPI PFNGLLISTBASEPROC glad_glListBase; +#define glListBase glad_glListBase +typedef void (APIENTRYP PFNGLBEGINPROC)(GLenum mode); +GLAPI PFNGLBEGINPROC glad_glBegin; +#define glBegin glad_glBegin +typedef void (APIENTRYP PFNGLBITMAPPROC)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap); +GLAPI PFNGLBITMAPPROC glad_glBitmap; +#define glBitmap glad_glBitmap +typedef void (APIENTRYP PFNGLCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue); +GLAPI PFNGLCOLOR3BPROC glad_glColor3b; +#define glColor3b glad_glColor3b +typedef void (APIENTRYP PFNGLCOLOR3BVPROC)(const GLbyte *v); +GLAPI PFNGLCOLOR3BVPROC glad_glColor3bv; +#define glColor3bv glad_glColor3bv +typedef void (APIENTRYP PFNGLCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue); +GLAPI PFNGLCOLOR3DPROC glad_glColor3d; +#define glColor3d glad_glColor3d +typedef void (APIENTRYP PFNGLCOLOR3DVPROC)(const GLdouble *v); +GLAPI PFNGLCOLOR3DVPROC glad_glColor3dv; +#define glColor3dv glad_glColor3dv +typedef void (APIENTRYP PFNGLCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue); +GLAPI PFNGLCOLOR3FPROC glad_glColor3f; +#define glColor3f glad_glColor3f +typedef void (APIENTRYP PFNGLCOLOR3FVPROC)(const GLfloat *v); +GLAPI PFNGLCOLOR3FVPROC glad_glColor3fv; +#define glColor3fv glad_glColor3fv +typedef void (APIENTRYP PFNGLCOLOR3IPROC)(GLint red, GLint green, GLint blue); +GLAPI PFNGLCOLOR3IPROC glad_glColor3i; +#define glColor3i glad_glColor3i +typedef void (APIENTRYP PFNGLCOLOR3IVPROC)(const GLint *v); +GLAPI PFNGLCOLOR3IVPROC glad_glColor3iv; +#define glColor3iv glad_glColor3iv +typedef void (APIENTRYP PFNGLCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue); +GLAPI PFNGLCOLOR3SPROC glad_glColor3s; +#define glColor3s glad_glColor3s +typedef void (APIENTRYP PFNGLCOLOR3SVPROC)(const GLshort *v); +GLAPI PFNGLCOLOR3SVPROC glad_glColor3sv; +#define glColor3sv glad_glColor3sv +typedef void (APIENTRYP PFNGLCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue); +GLAPI PFNGLCOLOR3UBPROC glad_glColor3ub; +#define glColor3ub glad_glColor3ub +typedef void (APIENTRYP PFNGLCOLOR3UBVPROC)(const GLubyte *v); +GLAPI PFNGLCOLOR3UBVPROC glad_glColor3ubv; +#define glColor3ubv glad_glColor3ubv +typedef void (APIENTRYP PFNGLCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue); +GLAPI PFNGLCOLOR3UIPROC glad_glColor3ui; +#define glColor3ui glad_glColor3ui +typedef void (APIENTRYP PFNGLCOLOR3UIVPROC)(const GLuint *v); +GLAPI PFNGLCOLOR3UIVPROC glad_glColor3uiv; +#define glColor3uiv glad_glColor3uiv +typedef void (APIENTRYP PFNGLCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue); +GLAPI PFNGLCOLOR3USPROC glad_glColor3us; +#define glColor3us glad_glColor3us +typedef void (APIENTRYP PFNGLCOLOR3USVPROC)(const GLushort *v); +GLAPI PFNGLCOLOR3USVPROC glad_glColor3usv; +#define glColor3usv glad_glColor3usv +typedef void (APIENTRYP PFNGLCOLOR4BPROC)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +GLAPI PFNGLCOLOR4BPROC glad_glColor4b; +#define glColor4b glad_glColor4b +typedef void (APIENTRYP PFNGLCOLOR4BVPROC)(const GLbyte *v); +GLAPI PFNGLCOLOR4BVPROC glad_glColor4bv; +#define glColor4bv glad_glColor4bv +typedef void (APIENTRYP PFNGLCOLOR4DPROC)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +GLAPI PFNGLCOLOR4DPROC glad_glColor4d; +#define glColor4d glad_glColor4d +typedef void (APIENTRYP PFNGLCOLOR4DVPROC)(const GLdouble *v); +GLAPI PFNGLCOLOR4DVPROC glad_glColor4dv; +#define glColor4dv glad_glColor4dv +typedef void (APIENTRYP PFNGLCOLOR4FPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCOLOR4FPROC glad_glColor4f; +#define glColor4f glad_glColor4f +typedef void (APIENTRYP PFNGLCOLOR4FVPROC)(const GLfloat *v); +GLAPI PFNGLCOLOR4FVPROC glad_glColor4fv; +#define glColor4fv glad_glColor4fv +typedef void (APIENTRYP PFNGLCOLOR4IPROC)(GLint red, GLint green, GLint blue, GLint alpha); +GLAPI PFNGLCOLOR4IPROC glad_glColor4i; +#define glColor4i glad_glColor4i +typedef void (APIENTRYP PFNGLCOLOR4IVPROC)(const GLint *v); +GLAPI PFNGLCOLOR4IVPROC glad_glColor4iv; +#define glColor4iv glad_glColor4iv +typedef void (APIENTRYP PFNGLCOLOR4SPROC)(GLshort red, GLshort green, GLshort blue, GLshort alpha); +GLAPI PFNGLCOLOR4SPROC glad_glColor4s; +#define glColor4s glad_glColor4s +typedef void (APIENTRYP PFNGLCOLOR4SVPROC)(const GLshort *v); +GLAPI PFNGLCOLOR4SVPROC glad_glColor4sv; +#define glColor4sv glad_glColor4sv +typedef void (APIENTRYP PFNGLCOLOR4UBPROC)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +GLAPI PFNGLCOLOR4UBPROC glad_glColor4ub; +#define glColor4ub glad_glColor4ub +typedef void (APIENTRYP PFNGLCOLOR4UBVPROC)(const GLubyte *v); +GLAPI PFNGLCOLOR4UBVPROC glad_glColor4ubv; +#define glColor4ubv glad_glColor4ubv +typedef void (APIENTRYP PFNGLCOLOR4UIPROC)(GLuint red, GLuint green, GLuint blue, GLuint alpha); +GLAPI PFNGLCOLOR4UIPROC glad_glColor4ui; +#define glColor4ui glad_glColor4ui +typedef void (APIENTRYP PFNGLCOLOR4UIVPROC)(const GLuint *v); +GLAPI PFNGLCOLOR4UIVPROC glad_glColor4uiv; +#define glColor4uiv glad_glColor4uiv +typedef void (APIENTRYP PFNGLCOLOR4USPROC)(GLushort red, GLushort green, GLushort blue, GLushort alpha); +GLAPI PFNGLCOLOR4USPROC glad_glColor4us; +#define glColor4us glad_glColor4us +typedef void (APIENTRYP PFNGLCOLOR4USVPROC)(const GLushort *v); +GLAPI PFNGLCOLOR4USVPROC glad_glColor4usv; +#define glColor4usv glad_glColor4usv +typedef void (APIENTRYP PFNGLEDGEFLAGPROC)(GLboolean flag); +GLAPI PFNGLEDGEFLAGPROC glad_glEdgeFlag; +#define glEdgeFlag glad_glEdgeFlag +typedef void (APIENTRYP PFNGLEDGEFLAGVPROC)(const GLboolean *flag); +GLAPI PFNGLEDGEFLAGVPROC glad_glEdgeFlagv; +#define glEdgeFlagv glad_glEdgeFlagv +typedef void (APIENTRYP PFNGLENDPROC)(void); +GLAPI PFNGLENDPROC glad_glEnd; +#define glEnd glad_glEnd +typedef void (APIENTRYP PFNGLINDEXDPROC)(GLdouble c); +GLAPI PFNGLINDEXDPROC glad_glIndexd; +#define glIndexd glad_glIndexd +typedef void (APIENTRYP PFNGLINDEXDVPROC)(const GLdouble *c); +GLAPI PFNGLINDEXDVPROC glad_glIndexdv; +#define glIndexdv glad_glIndexdv +typedef void (APIENTRYP PFNGLINDEXFPROC)(GLfloat c); +GLAPI PFNGLINDEXFPROC glad_glIndexf; +#define glIndexf glad_glIndexf +typedef void (APIENTRYP PFNGLINDEXFVPROC)(const GLfloat *c); +GLAPI PFNGLINDEXFVPROC glad_glIndexfv; +#define glIndexfv glad_glIndexfv +typedef void (APIENTRYP PFNGLINDEXIPROC)(GLint c); +GLAPI PFNGLINDEXIPROC glad_glIndexi; +#define glIndexi glad_glIndexi +typedef void (APIENTRYP PFNGLINDEXIVPROC)(const GLint *c); +GLAPI PFNGLINDEXIVPROC glad_glIndexiv; +#define glIndexiv glad_glIndexiv +typedef void (APIENTRYP PFNGLINDEXSPROC)(GLshort c); +GLAPI PFNGLINDEXSPROC glad_glIndexs; +#define glIndexs glad_glIndexs +typedef void (APIENTRYP PFNGLINDEXSVPROC)(const GLshort *c); +GLAPI PFNGLINDEXSVPROC glad_glIndexsv; +#define glIndexsv glad_glIndexsv +typedef void (APIENTRYP PFNGLNORMAL3BPROC)(GLbyte nx, GLbyte ny, GLbyte nz); +GLAPI PFNGLNORMAL3BPROC glad_glNormal3b; +#define glNormal3b glad_glNormal3b +typedef void (APIENTRYP PFNGLNORMAL3BVPROC)(const GLbyte *v); +GLAPI PFNGLNORMAL3BVPROC glad_glNormal3bv; +#define glNormal3bv glad_glNormal3bv +typedef void (APIENTRYP PFNGLNORMAL3DPROC)(GLdouble nx, GLdouble ny, GLdouble nz); +GLAPI PFNGLNORMAL3DPROC glad_glNormal3d; +#define glNormal3d glad_glNormal3d +typedef void (APIENTRYP PFNGLNORMAL3DVPROC)(const GLdouble *v); +GLAPI PFNGLNORMAL3DVPROC glad_glNormal3dv; +#define glNormal3dv glad_glNormal3dv +typedef void (APIENTRYP PFNGLNORMAL3FPROC)(GLfloat nx, GLfloat ny, GLfloat nz); +GLAPI PFNGLNORMAL3FPROC glad_glNormal3f; +#define glNormal3f glad_glNormal3f +typedef void (APIENTRYP PFNGLNORMAL3FVPROC)(const GLfloat *v); +GLAPI PFNGLNORMAL3FVPROC glad_glNormal3fv; +#define glNormal3fv glad_glNormal3fv +typedef void (APIENTRYP PFNGLNORMAL3IPROC)(GLint nx, GLint ny, GLint nz); +GLAPI PFNGLNORMAL3IPROC glad_glNormal3i; +#define glNormal3i glad_glNormal3i +typedef void (APIENTRYP PFNGLNORMAL3IVPROC)(const GLint *v); +GLAPI PFNGLNORMAL3IVPROC glad_glNormal3iv; +#define glNormal3iv glad_glNormal3iv +typedef void (APIENTRYP PFNGLNORMAL3SPROC)(GLshort nx, GLshort ny, GLshort nz); +GLAPI PFNGLNORMAL3SPROC glad_glNormal3s; +#define glNormal3s glad_glNormal3s +typedef void (APIENTRYP PFNGLNORMAL3SVPROC)(const GLshort *v); +GLAPI PFNGLNORMAL3SVPROC glad_glNormal3sv; +#define glNormal3sv glad_glNormal3sv +typedef void (APIENTRYP PFNGLRASTERPOS2DPROC)(GLdouble x, GLdouble y); +GLAPI PFNGLRASTERPOS2DPROC glad_glRasterPos2d; +#define glRasterPos2d glad_glRasterPos2d +typedef void (APIENTRYP PFNGLRASTERPOS2DVPROC)(const GLdouble *v); +GLAPI PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv; +#define glRasterPos2dv glad_glRasterPos2dv +typedef void (APIENTRYP PFNGLRASTERPOS2FPROC)(GLfloat x, GLfloat y); +GLAPI PFNGLRASTERPOS2FPROC glad_glRasterPos2f; +#define glRasterPos2f glad_glRasterPos2f +typedef void (APIENTRYP PFNGLRASTERPOS2FVPROC)(const GLfloat *v); +GLAPI PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv; +#define glRasterPos2fv glad_glRasterPos2fv +typedef void (APIENTRYP PFNGLRASTERPOS2IPROC)(GLint x, GLint y); +GLAPI PFNGLRASTERPOS2IPROC glad_glRasterPos2i; +#define glRasterPos2i glad_glRasterPos2i +typedef void (APIENTRYP PFNGLRASTERPOS2IVPROC)(const GLint *v); +GLAPI PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv; +#define glRasterPos2iv glad_glRasterPos2iv +typedef void (APIENTRYP PFNGLRASTERPOS2SPROC)(GLshort x, GLshort y); +GLAPI PFNGLRASTERPOS2SPROC glad_glRasterPos2s; +#define glRasterPos2s glad_glRasterPos2s +typedef void (APIENTRYP PFNGLRASTERPOS2SVPROC)(const GLshort *v); +GLAPI PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv; +#define glRasterPos2sv glad_glRasterPos2sv +typedef void (APIENTRYP PFNGLRASTERPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLRASTERPOS3DPROC glad_glRasterPos3d; +#define glRasterPos3d glad_glRasterPos3d +typedef void (APIENTRYP PFNGLRASTERPOS3DVPROC)(const GLdouble *v); +GLAPI PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv; +#define glRasterPos3dv glad_glRasterPos3dv +typedef void (APIENTRYP PFNGLRASTERPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLRASTERPOS3FPROC glad_glRasterPos3f; +#define glRasterPos3f glad_glRasterPos3f +typedef void (APIENTRYP PFNGLRASTERPOS3FVPROC)(const GLfloat *v); +GLAPI PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv; +#define glRasterPos3fv glad_glRasterPos3fv +typedef void (APIENTRYP PFNGLRASTERPOS3IPROC)(GLint x, GLint y, GLint z); +GLAPI PFNGLRASTERPOS3IPROC glad_glRasterPos3i; +#define glRasterPos3i glad_glRasterPos3i +typedef void (APIENTRYP PFNGLRASTERPOS3IVPROC)(const GLint *v); +GLAPI PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv; +#define glRasterPos3iv glad_glRasterPos3iv +typedef void (APIENTRYP PFNGLRASTERPOS3SPROC)(GLshort x, GLshort y, GLshort z); +GLAPI PFNGLRASTERPOS3SPROC glad_glRasterPos3s; +#define glRasterPos3s glad_glRasterPos3s +typedef void (APIENTRYP PFNGLRASTERPOS3SVPROC)(const GLshort *v); +GLAPI PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv; +#define glRasterPos3sv glad_glRasterPos3sv +typedef void (APIENTRYP PFNGLRASTERPOS4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLRASTERPOS4DPROC glad_glRasterPos4d; +#define glRasterPos4d glad_glRasterPos4d +typedef void (APIENTRYP PFNGLRASTERPOS4DVPROC)(const GLdouble *v); +GLAPI PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv; +#define glRasterPos4dv glad_glRasterPos4dv +typedef void (APIENTRYP PFNGLRASTERPOS4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLRASTERPOS4FPROC glad_glRasterPos4f; +#define glRasterPos4f glad_glRasterPos4f +typedef void (APIENTRYP PFNGLRASTERPOS4FVPROC)(const GLfloat *v); +GLAPI PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv; +#define glRasterPos4fv glad_glRasterPos4fv +typedef void (APIENTRYP PFNGLRASTERPOS4IPROC)(GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLRASTERPOS4IPROC glad_glRasterPos4i; +#define glRasterPos4i glad_glRasterPos4i +typedef void (APIENTRYP PFNGLRASTERPOS4IVPROC)(const GLint *v); +GLAPI PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv; +#define glRasterPos4iv glad_glRasterPos4iv +typedef void (APIENTRYP PFNGLRASTERPOS4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLRASTERPOS4SPROC glad_glRasterPos4s; +#define glRasterPos4s glad_glRasterPos4s +typedef void (APIENTRYP PFNGLRASTERPOS4SVPROC)(const GLshort *v); +GLAPI PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv; +#define glRasterPos4sv glad_glRasterPos4sv +typedef void (APIENTRYP PFNGLRECTDPROC)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +GLAPI PFNGLRECTDPROC glad_glRectd; +#define glRectd glad_glRectd +typedef void (APIENTRYP PFNGLRECTDVPROC)(const GLdouble *v1, const GLdouble *v2); +GLAPI PFNGLRECTDVPROC glad_glRectdv; +#define glRectdv glad_glRectdv +typedef void (APIENTRYP PFNGLRECTFPROC)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +GLAPI PFNGLRECTFPROC glad_glRectf; +#define glRectf glad_glRectf +typedef void (APIENTRYP PFNGLRECTFVPROC)(const GLfloat *v1, const GLfloat *v2); +GLAPI PFNGLRECTFVPROC glad_glRectfv; +#define glRectfv glad_glRectfv +typedef void (APIENTRYP PFNGLRECTIPROC)(GLint x1, GLint y1, GLint x2, GLint y2); +GLAPI PFNGLRECTIPROC glad_glRecti; +#define glRecti glad_glRecti +typedef void (APIENTRYP PFNGLRECTIVPROC)(const GLint *v1, const GLint *v2); +GLAPI PFNGLRECTIVPROC glad_glRectiv; +#define glRectiv glad_glRectiv +typedef void (APIENTRYP PFNGLRECTSPROC)(GLshort x1, GLshort y1, GLshort x2, GLshort y2); +GLAPI PFNGLRECTSPROC glad_glRects; +#define glRects glad_glRects +typedef void (APIENTRYP PFNGLRECTSVPROC)(const GLshort *v1, const GLshort *v2); +GLAPI PFNGLRECTSVPROC glad_glRectsv; +#define glRectsv glad_glRectsv +typedef void (APIENTRYP PFNGLTEXCOORD1DPROC)(GLdouble s); +GLAPI PFNGLTEXCOORD1DPROC glad_glTexCoord1d; +#define glTexCoord1d glad_glTexCoord1d +typedef void (APIENTRYP PFNGLTEXCOORD1DVPROC)(const GLdouble *v); +GLAPI PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv; +#define glTexCoord1dv glad_glTexCoord1dv +typedef void (APIENTRYP PFNGLTEXCOORD1FPROC)(GLfloat s); +GLAPI PFNGLTEXCOORD1FPROC glad_glTexCoord1f; +#define glTexCoord1f glad_glTexCoord1f +typedef void (APIENTRYP PFNGLTEXCOORD1FVPROC)(const GLfloat *v); +GLAPI PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv; +#define glTexCoord1fv glad_glTexCoord1fv +typedef void (APIENTRYP PFNGLTEXCOORD1IPROC)(GLint s); +GLAPI PFNGLTEXCOORD1IPROC glad_glTexCoord1i; +#define glTexCoord1i glad_glTexCoord1i +typedef void (APIENTRYP PFNGLTEXCOORD1IVPROC)(const GLint *v); +GLAPI PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv; +#define glTexCoord1iv glad_glTexCoord1iv +typedef void (APIENTRYP PFNGLTEXCOORD1SPROC)(GLshort s); +GLAPI PFNGLTEXCOORD1SPROC glad_glTexCoord1s; +#define glTexCoord1s glad_glTexCoord1s +typedef void (APIENTRYP PFNGLTEXCOORD1SVPROC)(const GLshort *v); +GLAPI PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv; +#define glTexCoord1sv glad_glTexCoord1sv +typedef void (APIENTRYP PFNGLTEXCOORD2DPROC)(GLdouble s, GLdouble t); +GLAPI PFNGLTEXCOORD2DPROC glad_glTexCoord2d; +#define glTexCoord2d glad_glTexCoord2d +typedef void (APIENTRYP PFNGLTEXCOORD2DVPROC)(const GLdouble *v); +GLAPI PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv; +#define glTexCoord2dv glad_glTexCoord2dv +typedef void (APIENTRYP PFNGLTEXCOORD2FPROC)(GLfloat s, GLfloat t); +GLAPI PFNGLTEXCOORD2FPROC glad_glTexCoord2f; +#define glTexCoord2f glad_glTexCoord2f +typedef void (APIENTRYP PFNGLTEXCOORD2FVPROC)(const GLfloat *v); +GLAPI PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv; +#define glTexCoord2fv glad_glTexCoord2fv +typedef void (APIENTRYP PFNGLTEXCOORD2IPROC)(GLint s, GLint t); +GLAPI PFNGLTEXCOORD2IPROC glad_glTexCoord2i; +#define glTexCoord2i glad_glTexCoord2i +typedef void (APIENTRYP PFNGLTEXCOORD2IVPROC)(const GLint *v); +GLAPI PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv; +#define glTexCoord2iv glad_glTexCoord2iv +typedef void (APIENTRYP PFNGLTEXCOORD2SPROC)(GLshort s, GLshort t); +GLAPI PFNGLTEXCOORD2SPROC glad_glTexCoord2s; +#define glTexCoord2s glad_glTexCoord2s +typedef void (APIENTRYP PFNGLTEXCOORD2SVPROC)(const GLshort *v); +GLAPI PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv; +#define glTexCoord2sv glad_glTexCoord2sv +typedef void (APIENTRYP PFNGLTEXCOORD3DPROC)(GLdouble s, GLdouble t, GLdouble r); +GLAPI PFNGLTEXCOORD3DPROC glad_glTexCoord3d; +#define glTexCoord3d glad_glTexCoord3d +typedef void (APIENTRYP PFNGLTEXCOORD3DVPROC)(const GLdouble *v); +GLAPI PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv; +#define glTexCoord3dv glad_glTexCoord3dv +typedef void (APIENTRYP PFNGLTEXCOORD3FPROC)(GLfloat s, GLfloat t, GLfloat r); +GLAPI PFNGLTEXCOORD3FPROC glad_glTexCoord3f; +#define glTexCoord3f glad_glTexCoord3f +typedef void (APIENTRYP PFNGLTEXCOORD3FVPROC)(const GLfloat *v); +GLAPI PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv; +#define glTexCoord3fv glad_glTexCoord3fv +typedef void (APIENTRYP PFNGLTEXCOORD3IPROC)(GLint s, GLint t, GLint r); +GLAPI PFNGLTEXCOORD3IPROC glad_glTexCoord3i; +#define glTexCoord3i glad_glTexCoord3i +typedef void (APIENTRYP PFNGLTEXCOORD3IVPROC)(const GLint *v); +GLAPI PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv; +#define glTexCoord3iv glad_glTexCoord3iv +typedef void (APIENTRYP PFNGLTEXCOORD3SPROC)(GLshort s, GLshort t, GLshort r); +GLAPI PFNGLTEXCOORD3SPROC glad_glTexCoord3s; +#define glTexCoord3s glad_glTexCoord3s +typedef void (APIENTRYP PFNGLTEXCOORD3SVPROC)(const GLshort *v); +GLAPI PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv; +#define glTexCoord3sv glad_glTexCoord3sv +typedef void (APIENTRYP PFNGLTEXCOORD4DPROC)(GLdouble s, GLdouble t, GLdouble r, GLdouble q); +GLAPI PFNGLTEXCOORD4DPROC glad_glTexCoord4d; +#define glTexCoord4d glad_glTexCoord4d +typedef void (APIENTRYP PFNGLTEXCOORD4DVPROC)(const GLdouble *v); +GLAPI PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv; +#define glTexCoord4dv glad_glTexCoord4dv +typedef void (APIENTRYP PFNGLTEXCOORD4FPROC)(GLfloat s, GLfloat t, GLfloat r, GLfloat q); +GLAPI PFNGLTEXCOORD4FPROC glad_glTexCoord4f; +#define glTexCoord4f glad_glTexCoord4f +typedef void (APIENTRYP PFNGLTEXCOORD4FVPROC)(const GLfloat *v); +GLAPI PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv; +#define glTexCoord4fv glad_glTexCoord4fv +typedef void (APIENTRYP PFNGLTEXCOORD4IPROC)(GLint s, GLint t, GLint r, GLint q); +GLAPI PFNGLTEXCOORD4IPROC glad_glTexCoord4i; +#define glTexCoord4i glad_glTexCoord4i +typedef void (APIENTRYP PFNGLTEXCOORD4IVPROC)(const GLint *v); +GLAPI PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv; +#define glTexCoord4iv glad_glTexCoord4iv +typedef void (APIENTRYP PFNGLTEXCOORD4SPROC)(GLshort s, GLshort t, GLshort r, GLshort q); +GLAPI PFNGLTEXCOORD4SPROC glad_glTexCoord4s; +#define glTexCoord4s glad_glTexCoord4s +typedef void (APIENTRYP PFNGLTEXCOORD4SVPROC)(const GLshort *v); +GLAPI PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv; +#define glTexCoord4sv glad_glTexCoord4sv +typedef void (APIENTRYP PFNGLVERTEX2DPROC)(GLdouble x, GLdouble y); +GLAPI PFNGLVERTEX2DPROC glad_glVertex2d; +#define glVertex2d glad_glVertex2d +typedef void (APIENTRYP PFNGLVERTEX2DVPROC)(const GLdouble *v); +GLAPI PFNGLVERTEX2DVPROC glad_glVertex2dv; +#define glVertex2dv glad_glVertex2dv +typedef void (APIENTRYP PFNGLVERTEX2FPROC)(GLfloat x, GLfloat y); +GLAPI PFNGLVERTEX2FPROC glad_glVertex2f; +#define glVertex2f glad_glVertex2f +typedef void (APIENTRYP PFNGLVERTEX2FVPROC)(const GLfloat *v); +GLAPI PFNGLVERTEX2FVPROC glad_glVertex2fv; +#define glVertex2fv glad_glVertex2fv +typedef void (APIENTRYP PFNGLVERTEX2IPROC)(GLint x, GLint y); +GLAPI PFNGLVERTEX2IPROC glad_glVertex2i; +#define glVertex2i glad_glVertex2i +typedef void (APIENTRYP PFNGLVERTEX2IVPROC)(const GLint *v); +GLAPI PFNGLVERTEX2IVPROC glad_glVertex2iv; +#define glVertex2iv glad_glVertex2iv +typedef void (APIENTRYP PFNGLVERTEX2SPROC)(GLshort x, GLshort y); +GLAPI PFNGLVERTEX2SPROC glad_glVertex2s; +#define glVertex2s glad_glVertex2s +typedef void (APIENTRYP PFNGLVERTEX2SVPROC)(const GLshort *v); +GLAPI PFNGLVERTEX2SVPROC glad_glVertex2sv; +#define glVertex2sv glad_glVertex2sv +typedef void (APIENTRYP PFNGLVERTEX3DPROC)(GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEX3DPROC glad_glVertex3d; +#define glVertex3d glad_glVertex3d +typedef void (APIENTRYP PFNGLVERTEX3DVPROC)(const GLdouble *v); +GLAPI PFNGLVERTEX3DVPROC glad_glVertex3dv; +#define glVertex3dv glad_glVertex3dv +typedef void (APIENTRYP PFNGLVERTEX3FPROC)(GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEX3FPROC glad_glVertex3f; +#define glVertex3f glad_glVertex3f +typedef void (APIENTRYP PFNGLVERTEX3FVPROC)(const GLfloat *v); +GLAPI PFNGLVERTEX3FVPROC glad_glVertex3fv; +#define glVertex3fv glad_glVertex3fv +typedef void (APIENTRYP PFNGLVERTEX3IPROC)(GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEX3IPROC glad_glVertex3i; +#define glVertex3i glad_glVertex3i +typedef void (APIENTRYP PFNGLVERTEX3IVPROC)(const GLint *v); +GLAPI PFNGLVERTEX3IVPROC glad_glVertex3iv; +#define glVertex3iv glad_glVertex3iv +typedef void (APIENTRYP PFNGLVERTEX3SPROC)(GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEX3SPROC glad_glVertex3s; +#define glVertex3s glad_glVertex3s +typedef void (APIENTRYP PFNGLVERTEX3SVPROC)(const GLshort *v); +GLAPI PFNGLVERTEX3SVPROC glad_glVertex3sv; +#define glVertex3sv glad_glVertex3sv +typedef void (APIENTRYP PFNGLVERTEX4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEX4DPROC glad_glVertex4d; +#define glVertex4d glad_glVertex4d +typedef void (APIENTRYP PFNGLVERTEX4DVPROC)(const GLdouble *v); +GLAPI PFNGLVERTEX4DVPROC glad_glVertex4dv; +#define glVertex4dv glad_glVertex4dv +typedef void (APIENTRYP PFNGLVERTEX4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEX4FPROC glad_glVertex4f; +#define glVertex4f glad_glVertex4f +typedef void (APIENTRYP PFNGLVERTEX4FVPROC)(const GLfloat *v); +GLAPI PFNGLVERTEX4FVPROC glad_glVertex4fv; +#define glVertex4fv glad_glVertex4fv +typedef void (APIENTRYP PFNGLVERTEX4IPROC)(GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEX4IPROC glad_glVertex4i; +#define glVertex4i glad_glVertex4i +typedef void (APIENTRYP PFNGLVERTEX4IVPROC)(const GLint *v); +GLAPI PFNGLVERTEX4IVPROC glad_glVertex4iv; +#define glVertex4iv glad_glVertex4iv +typedef void (APIENTRYP PFNGLVERTEX4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEX4SPROC glad_glVertex4s; +#define glVertex4s glad_glVertex4s +typedef void (APIENTRYP PFNGLVERTEX4SVPROC)(const GLshort *v); +GLAPI PFNGLVERTEX4SVPROC glad_glVertex4sv; +#define glVertex4sv glad_glVertex4sv +typedef void (APIENTRYP PFNGLCLIPPLANEPROC)(GLenum plane, const GLdouble *equation); +GLAPI PFNGLCLIPPLANEPROC glad_glClipPlane; +#define glClipPlane glad_glClipPlane +typedef void (APIENTRYP PFNGLCOLORMATERIALPROC)(GLenum face, GLenum mode); +GLAPI PFNGLCOLORMATERIALPROC glad_glColorMaterial; +#define glColorMaterial glad_glColorMaterial +typedef void (APIENTRYP PFNGLFOGFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLFOGFPROC glad_glFogf; +#define glFogf glad_glFogf +typedef void (APIENTRYP PFNGLFOGFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLFOGFVPROC glad_glFogfv; +#define glFogfv glad_glFogfv +typedef void (APIENTRYP PFNGLFOGIPROC)(GLenum pname, GLint param); +GLAPI PFNGLFOGIPROC glad_glFogi; +#define glFogi glad_glFogi +typedef void (APIENTRYP PFNGLFOGIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLFOGIVPROC glad_glFogiv; +#define glFogiv glad_glFogiv +typedef void (APIENTRYP PFNGLLIGHTFPROC)(GLenum light, GLenum pname, GLfloat param); +GLAPI PFNGLLIGHTFPROC glad_glLightf; +#define glLightf glad_glLightf +typedef void (APIENTRYP PFNGLLIGHTFVPROC)(GLenum light, GLenum pname, const GLfloat *params); +GLAPI PFNGLLIGHTFVPROC glad_glLightfv; +#define glLightfv glad_glLightfv +typedef void (APIENTRYP PFNGLLIGHTIPROC)(GLenum light, GLenum pname, GLint param); +GLAPI PFNGLLIGHTIPROC glad_glLighti; +#define glLighti glad_glLighti +typedef void (APIENTRYP PFNGLLIGHTIVPROC)(GLenum light, GLenum pname, const GLint *params); +GLAPI PFNGLLIGHTIVPROC glad_glLightiv; +#define glLightiv glad_glLightiv +typedef void (APIENTRYP PFNGLLIGHTMODELFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLLIGHTMODELFPROC glad_glLightModelf; +#define glLightModelf glad_glLightModelf +typedef void (APIENTRYP PFNGLLIGHTMODELFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLLIGHTMODELFVPROC glad_glLightModelfv; +#define glLightModelfv glad_glLightModelfv +typedef void (APIENTRYP PFNGLLIGHTMODELIPROC)(GLenum pname, GLint param); +GLAPI PFNGLLIGHTMODELIPROC glad_glLightModeli; +#define glLightModeli glad_glLightModeli +typedef void (APIENTRYP PFNGLLIGHTMODELIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLLIGHTMODELIVPROC glad_glLightModeliv; +#define glLightModeliv glad_glLightModeliv +typedef void (APIENTRYP PFNGLLINESTIPPLEPROC)(GLint factor, GLushort pattern); +GLAPI PFNGLLINESTIPPLEPROC glad_glLineStipple; +#define glLineStipple glad_glLineStipple +typedef void (APIENTRYP PFNGLMATERIALFPROC)(GLenum face, GLenum pname, GLfloat param); +GLAPI PFNGLMATERIALFPROC glad_glMaterialf; +#define glMaterialf glad_glMaterialf +typedef void (APIENTRYP PFNGLMATERIALFVPROC)(GLenum face, GLenum pname, const GLfloat *params); +GLAPI PFNGLMATERIALFVPROC glad_glMaterialfv; +#define glMaterialfv glad_glMaterialfv +typedef void (APIENTRYP PFNGLMATERIALIPROC)(GLenum face, GLenum pname, GLint param); +GLAPI PFNGLMATERIALIPROC glad_glMateriali; +#define glMateriali glad_glMateriali +typedef void (APIENTRYP PFNGLMATERIALIVPROC)(GLenum face, GLenum pname, const GLint *params); +GLAPI PFNGLMATERIALIVPROC glad_glMaterialiv; +#define glMaterialiv glad_glMaterialiv +typedef void (APIENTRYP PFNGLPOLYGONSTIPPLEPROC)(const GLubyte *mask); +GLAPI PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple; +#define glPolygonStipple glad_glPolygonStipple +typedef void (APIENTRYP PFNGLSHADEMODELPROC)(GLenum mode); +GLAPI PFNGLSHADEMODELPROC glad_glShadeModel; +#define glShadeModel glad_glShadeModel +typedef void (APIENTRYP PFNGLTEXENVFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXENVFPROC glad_glTexEnvf; +#define glTexEnvf glad_glTexEnvf +typedef void (APIENTRYP PFNGLTEXENVFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXENVFVPROC glad_glTexEnvfv; +#define glTexEnvfv glad_glTexEnvfv +typedef void (APIENTRYP PFNGLTEXENVIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXENVIPROC glad_glTexEnvi; +#define glTexEnvi glad_glTexEnvi +typedef void (APIENTRYP PFNGLTEXENVIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXENVIVPROC glad_glTexEnviv; +#define glTexEnviv glad_glTexEnviv +typedef void (APIENTRYP PFNGLTEXGENDPROC)(GLenum coord, GLenum pname, GLdouble param); +GLAPI PFNGLTEXGENDPROC glad_glTexGend; +#define glTexGend glad_glTexGend +typedef void (APIENTRYP PFNGLTEXGENDVPROC)(GLenum coord, GLenum pname, const GLdouble *params); +GLAPI PFNGLTEXGENDVPROC glad_glTexGendv; +#define glTexGendv glad_glTexGendv +typedef void (APIENTRYP PFNGLTEXGENFPROC)(GLenum coord, GLenum pname, GLfloat param); +GLAPI PFNGLTEXGENFPROC glad_glTexGenf; +#define glTexGenf glad_glTexGenf +typedef void (APIENTRYP PFNGLTEXGENFVPROC)(GLenum coord, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXGENFVPROC glad_glTexGenfv; +#define glTexGenfv glad_glTexGenfv +typedef void (APIENTRYP PFNGLTEXGENIPROC)(GLenum coord, GLenum pname, GLint param); +GLAPI PFNGLTEXGENIPROC glad_glTexGeni; +#define glTexGeni glad_glTexGeni +typedef void (APIENTRYP PFNGLTEXGENIVPROC)(GLenum coord, GLenum pname, const GLint *params); +GLAPI PFNGLTEXGENIVPROC glad_glTexGeniv; +#define glTexGeniv glad_glTexGeniv +typedef void (APIENTRYP PFNGLFEEDBACKBUFFERPROC)(GLsizei size, GLenum type, GLfloat *buffer); +GLAPI PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer; +#define glFeedbackBuffer glad_glFeedbackBuffer +typedef void (APIENTRYP PFNGLSELECTBUFFERPROC)(GLsizei size, GLuint *buffer); +GLAPI PFNGLSELECTBUFFERPROC glad_glSelectBuffer; +#define glSelectBuffer glad_glSelectBuffer +typedef GLint (APIENTRYP PFNGLRENDERMODEPROC)(GLenum mode); +GLAPI PFNGLRENDERMODEPROC glad_glRenderMode; +#define glRenderMode glad_glRenderMode +typedef void (APIENTRYP PFNGLINITNAMESPROC)(void); +GLAPI PFNGLINITNAMESPROC glad_glInitNames; +#define glInitNames glad_glInitNames +typedef void (APIENTRYP PFNGLLOADNAMEPROC)(GLuint name); +GLAPI PFNGLLOADNAMEPROC glad_glLoadName; +#define glLoadName glad_glLoadName +typedef void (APIENTRYP PFNGLPASSTHROUGHPROC)(GLfloat token); +GLAPI PFNGLPASSTHROUGHPROC glad_glPassThrough; +#define glPassThrough glad_glPassThrough +typedef void (APIENTRYP PFNGLPOPNAMEPROC)(void); +GLAPI PFNGLPOPNAMEPROC glad_glPopName; +#define glPopName glad_glPopName +typedef void (APIENTRYP PFNGLPUSHNAMEPROC)(GLuint name); +GLAPI PFNGLPUSHNAMEPROC glad_glPushName; +#define glPushName glad_glPushName +typedef void (APIENTRYP PFNGLCLEARACCUMPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARACCUMPROC glad_glClearAccum; +#define glClearAccum glad_glClearAccum +typedef void (APIENTRYP PFNGLCLEARINDEXPROC)(GLfloat c); +GLAPI PFNGLCLEARINDEXPROC glad_glClearIndex; +#define glClearIndex glad_glClearIndex +typedef void (APIENTRYP PFNGLINDEXMASKPROC)(GLuint mask); +GLAPI PFNGLINDEXMASKPROC glad_glIndexMask; +#define glIndexMask glad_glIndexMask +typedef void (APIENTRYP PFNGLACCUMPROC)(GLenum op, GLfloat value); +GLAPI PFNGLACCUMPROC glad_glAccum; +#define glAccum glad_glAccum +typedef void (APIENTRYP PFNGLPOPATTRIBPROC)(void); +GLAPI PFNGLPOPATTRIBPROC glad_glPopAttrib; +#define glPopAttrib glad_glPopAttrib +typedef void (APIENTRYP PFNGLPUSHATTRIBPROC)(GLbitfield mask); +GLAPI PFNGLPUSHATTRIBPROC glad_glPushAttrib; +#define glPushAttrib glad_glPushAttrib +typedef void (APIENTRYP PFNGLMAP1DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points); +GLAPI PFNGLMAP1DPROC glad_glMap1d; +#define glMap1d glad_glMap1d +typedef void (APIENTRYP PFNGLMAP1FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points); +GLAPI PFNGLMAP1FPROC glad_glMap1f; +#define glMap1f glad_glMap1f +typedef void (APIENTRYP PFNGLMAP2DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points); +GLAPI PFNGLMAP2DPROC glad_glMap2d; +#define glMap2d glad_glMap2d +typedef void (APIENTRYP PFNGLMAP2FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points); +GLAPI PFNGLMAP2FPROC glad_glMap2f; +#define glMap2f glad_glMap2f +typedef void (APIENTRYP PFNGLMAPGRID1DPROC)(GLint un, GLdouble u1, GLdouble u2); +GLAPI PFNGLMAPGRID1DPROC glad_glMapGrid1d; +#define glMapGrid1d glad_glMapGrid1d +typedef void (APIENTRYP PFNGLMAPGRID1FPROC)(GLint un, GLfloat u1, GLfloat u2); +GLAPI PFNGLMAPGRID1FPROC glad_glMapGrid1f; +#define glMapGrid1f glad_glMapGrid1f +typedef void (APIENTRYP PFNGLMAPGRID2DPROC)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +GLAPI PFNGLMAPGRID2DPROC glad_glMapGrid2d; +#define glMapGrid2d glad_glMapGrid2d +typedef void (APIENTRYP PFNGLMAPGRID2FPROC)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +GLAPI PFNGLMAPGRID2FPROC glad_glMapGrid2f; +#define glMapGrid2f glad_glMapGrid2f +typedef void (APIENTRYP PFNGLEVALCOORD1DPROC)(GLdouble u); +GLAPI PFNGLEVALCOORD1DPROC glad_glEvalCoord1d; +#define glEvalCoord1d glad_glEvalCoord1d +typedef void (APIENTRYP PFNGLEVALCOORD1DVPROC)(const GLdouble *u); +GLAPI PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv; +#define glEvalCoord1dv glad_glEvalCoord1dv +typedef void (APIENTRYP PFNGLEVALCOORD1FPROC)(GLfloat u); +GLAPI PFNGLEVALCOORD1FPROC glad_glEvalCoord1f; +#define glEvalCoord1f glad_glEvalCoord1f +typedef void (APIENTRYP PFNGLEVALCOORD1FVPROC)(const GLfloat *u); +GLAPI PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv; +#define glEvalCoord1fv glad_glEvalCoord1fv +typedef void (APIENTRYP PFNGLEVALCOORD2DPROC)(GLdouble u, GLdouble v); +GLAPI PFNGLEVALCOORD2DPROC glad_glEvalCoord2d; +#define glEvalCoord2d glad_glEvalCoord2d +typedef void (APIENTRYP PFNGLEVALCOORD2DVPROC)(const GLdouble *u); +GLAPI PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv; +#define glEvalCoord2dv glad_glEvalCoord2dv +typedef void (APIENTRYP PFNGLEVALCOORD2FPROC)(GLfloat u, GLfloat v); +GLAPI PFNGLEVALCOORD2FPROC glad_glEvalCoord2f; +#define glEvalCoord2f glad_glEvalCoord2f +typedef void (APIENTRYP PFNGLEVALCOORD2FVPROC)(const GLfloat *u); +GLAPI PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv; +#define glEvalCoord2fv glad_glEvalCoord2fv +typedef void (APIENTRYP PFNGLEVALMESH1PROC)(GLenum mode, GLint i1, GLint i2); +GLAPI PFNGLEVALMESH1PROC glad_glEvalMesh1; +#define glEvalMesh1 glad_glEvalMesh1 +typedef void (APIENTRYP PFNGLEVALPOINT1PROC)(GLint i); +GLAPI PFNGLEVALPOINT1PROC glad_glEvalPoint1; +#define glEvalPoint1 glad_glEvalPoint1 +typedef void (APIENTRYP PFNGLEVALMESH2PROC)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +GLAPI PFNGLEVALMESH2PROC glad_glEvalMesh2; +#define glEvalMesh2 glad_glEvalMesh2 +typedef void (APIENTRYP PFNGLEVALPOINT2PROC)(GLint i, GLint j); +GLAPI PFNGLEVALPOINT2PROC glad_glEvalPoint2; +#define glEvalPoint2 glad_glEvalPoint2 +typedef void (APIENTRYP PFNGLALPHAFUNCPROC)(GLenum func, GLfloat ref); +GLAPI PFNGLALPHAFUNCPROC glad_glAlphaFunc; +#define glAlphaFunc glad_glAlphaFunc +typedef void (APIENTRYP PFNGLPIXELZOOMPROC)(GLfloat xfactor, GLfloat yfactor); +GLAPI PFNGLPIXELZOOMPROC glad_glPixelZoom; +#define glPixelZoom glad_glPixelZoom +typedef void (APIENTRYP PFNGLPIXELTRANSFERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf; +#define glPixelTransferf glad_glPixelTransferf +typedef void (APIENTRYP PFNGLPIXELTRANSFERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi; +#define glPixelTransferi glad_glPixelTransferi +typedef void (APIENTRYP PFNGLPIXELMAPFVPROC)(GLenum map, GLsizei mapsize, const GLfloat *values); +GLAPI PFNGLPIXELMAPFVPROC glad_glPixelMapfv; +#define glPixelMapfv glad_glPixelMapfv +typedef void (APIENTRYP PFNGLPIXELMAPUIVPROC)(GLenum map, GLsizei mapsize, const GLuint *values); +GLAPI PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv; +#define glPixelMapuiv glad_glPixelMapuiv +typedef void (APIENTRYP PFNGLPIXELMAPUSVPROC)(GLenum map, GLsizei mapsize, const GLushort *values); +GLAPI PFNGLPIXELMAPUSVPROC glad_glPixelMapusv; +#define glPixelMapusv glad_glPixelMapusv +typedef void (APIENTRYP PFNGLCOPYPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); +GLAPI PFNGLCOPYPIXELSPROC glad_glCopyPixels; +#define glCopyPixels glad_glCopyPixels +typedef void (APIENTRYP PFNGLDRAWPIXELSPROC)(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLDRAWPIXELSPROC glad_glDrawPixels; +#define glDrawPixels glad_glDrawPixels +typedef void (APIENTRYP PFNGLGETCLIPPLANEPROC)(GLenum plane, GLdouble *equation); +GLAPI PFNGLGETCLIPPLANEPROC glad_glGetClipPlane; +#define glGetClipPlane glad_glGetClipPlane +typedef void (APIENTRYP PFNGLGETLIGHTFVPROC)(GLenum light, GLenum pname, GLfloat *params); +GLAPI PFNGLGETLIGHTFVPROC glad_glGetLightfv; +#define glGetLightfv glad_glGetLightfv +typedef void (APIENTRYP PFNGLGETLIGHTIVPROC)(GLenum light, GLenum pname, GLint *params); +GLAPI PFNGLGETLIGHTIVPROC glad_glGetLightiv; +#define glGetLightiv glad_glGetLightiv +typedef void (APIENTRYP PFNGLGETMAPDVPROC)(GLenum target, GLenum query, GLdouble *v); +GLAPI PFNGLGETMAPDVPROC glad_glGetMapdv; +#define glGetMapdv glad_glGetMapdv +typedef void (APIENTRYP PFNGLGETMAPFVPROC)(GLenum target, GLenum query, GLfloat *v); +GLAPI PFNGLGETMAPFVPROC glad_glGetMapfv; +#define glGetMapfv glad_glGetMapfv +typedef void (APIENTRYP PFNGLGETMAPIVPROC)(GLenum target, GLenum query, GLint *v); +GLAPI PFNGLGETMAPIVPROC glad_glGetMapiv; +#define glGetMapiv glad_glGetMapiv +typedef void (APIENTRYP PFNGLGETMATERIALFVPROC)(GLenum face, GLenum pname, GLfloat *params); +GLAPI PFNGLGETMATERIALFVPROC glad_glGetMaterialfv; +#define glGetMaterialfv glad_glGetMaterialfv +typedef void (APIENTRYP PFNGLGETMATERIALIVPROC)(GLenum face, GLenum pname, GLint *params); +GLAPI PFNGLGETMATERIALIVPROC glad_glGetMaterialiv; +#define glGetMaterialiv glad_glGetMaterialiv +typedef void (APIENTRYP PFNGLGETPIXELMAPFVPROC)(GLenum map, GLfloat *values); +GLAPI PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv; +#define glGetPixelMapfv glad_glGetPixelMapfv +typedef void (APIENTRYP PFNGLGETPIXELMAPUIVPROC)(GLenum map, GLuint *values); +GLAPI PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv; +#define glGetPixelMapuiv glad_glGetPixelMapuiv +typedef void (APIENTRYP PFNGLGETPIXELMAPUSVPROC)(GLenum map, GLushort *values); +GLAPI PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv; +#define glGetPixelMapusv glad_glGetPixelMapusv +typedef void (APIENTRYP PFNGLGETPOLYGONSTIPPLEPROC)(GLubyte *mask); +GLAPI PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple; +#define glGetPolygonStipple glad_glGetPolygonStipple +typedef void (APIENTRYP PFNGLGETTEXENVFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv; +#define glGetTexEnvfv glad_glGetTexEnvfv +typedef void (APIENTRYP PFNGLGETTEXENVIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXENVIVPROC glad_glGetTexEnviv; +#define glGetTexEnviv glad_glGetTexEnviv +typedef void (APIENTRYP PFNGLGETTEXGENDVPROC)(GLenum coord, GLenum pname, GLdouble *params); +GLAPI PFNGLGETTEXGENDVPROC glad_glGetTexGendv; +#define glGetTexGendv glad_glGetTexGendv +typedef void (APIENTRYP PFNGLGETTEXGENFVPROC)(GLenum coord, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXGENFVPROC glad_glGetTexGenfv; +#define glGetTexGenfv glad_glGetTexGenfv +typedef void (APIENTRYP PFNGLGETTEXGENIVPROC)(GLenum coord, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXGENIVPROC glad_glGetTexGeniv; +#define glGetTexGeniv glad_glGetTexGeniv +typedef GLboolean (APIENTRYP PFNGLISLISTPROC)(GLuint list); +GLAPI PFNGLISLISTPROC glad_glIsList; +#define glIsList glad_glIsList +typedef void (APIENTRYP PFNGLFRUSTUMPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLAPI PFNGLFRUSTUMPROC glad_glFrustum; +#define glFrustum glad_glFrustum +typedef void (APIENTRYP PFNGLLOADIDENTITYPROC)(void); +GLAPI PFNGLLOADIDENTITYPROC glad_glLoadIdentity; +#define glLoadIdentity glad_glLoadIdentity +typedef void (APIENTRYP PFNGLLOADMATRIXFPROC)(const GLfloat *m); +GLAPI PFNGLLOADMATRIXFPROC glad_glLoadMatrixf; +#define glLoadMatrixf glad_glLoadMatrixf +typedef void (APIENTRYP PFNGLLOADMATRIXDPROC)(const GLdouble *m); +GLAPI PFNGLLOADMATRIXDPROC glad_glLoadMatrixd; +#define glLoadMatrixd glad_glLoadMatrixd +typedef void (APIENTRYP PFNGLMATRIXMODEPROC)(GLenum mode); +GLAPI PFNGLMATRIXMODEPROC glad_glMatrixMode; +#define glMatrixMode glad_glMatrixMode +typedef void (APIENTRYP PFNGLMULTMATRIXFPROC)(const GLfloat *m); +GLAPI PFNGLMULTMATRIXFPROC glad_glMultMatrixf; +#define glMultMatrixf glad_glMultMatrixf +typedef void (APIENTRYP PFNGLMULTMATRIXDPROC)(const GLdouble *m); +GLAPI PFNGLMULTMATRIXDPROC glad_glMultMatrixd; +#define glMultMatrixd glad_glMultMatrixd +typedef void (APIENTRYP PFNGLORTHOPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLAPI PFNGLORTHOPROC glad_glOrtho; +#define glOrtho glad_glOrtho +typedef void (APIENTRYP PFNGLPOPMATRIXPROC)(void); +GLAPI PFNGLPOPMATRIXPROC glad_glPopMatrix; +#define glPopMatrix glad_glPopMatrix +typedef void (APIENTRYP PFNGLPUSHMATRIXPROC)(void); +GLAPI PFNGLPUSHMATRIXPROC glad_glPushMatrix; +#define glPushMatrix glad_glPushMatrix +typedef void (APIENTRYP PFNGLROTATEDPROC)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLROTATEDPROC glad_glRotated; +#define glRotated glad_glRotated +typedef void (APIENTRYP PFNGLROTATEFPROC)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLROTATEFPROC glad_glRotatef; +#define glRotatef glad_glRotatef +typedef void (APIENTRYP PFNGLSCALEDPROC)(GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLSCALEDPROC glad_glScaled; +#define glScaled glad_glScaled +typedef void (APIENTRYP PFNGLSCALEFPROC)(GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLSCALEFPROC glad_glScalef; +#define glScalef glad_glScalef +typedef void (APIENTRYP PFNGLTRANSLATEDPROC)(GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLTRANSLATEDPROC glad_glTranslated; +#define glTranslated glad_glTranslated +typedef void (APIENTRYP PFNGLTRANSLATEFPROC)(GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLTRANSLATEFPROC glad_glTranslatef; +#define glTranslatef glad_glTranslatef +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLGETPOINTERVPROC)(GLenum pname, void **params); +GLAPI PFNGLGETPOINTERVPROC glad_glGetPointerv; +#define glGetPointerv glad_glGetPointerv +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +typedef void (APIENTRYP PFNGLARRAYELEMENTPROC)(GLint i); +GLAPI PFNGLARRAYELEMENTPROC glad_glArrayElement; +#define glArrayElement glad_glArrayElement +typedef void (APIENTRYP PFNGLCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLCOLORPOINTERPROC glad_glColorPointer; +#define glColorPointer glad_glColorPointer +typedef void (APIENTRYP PFNGLDISABLECLIENTSTATEPROC)(GLenum array); +GLAPI PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState; +#define glDisableClientState glad_glDisableClientState +typedef void (APIENTRYP PFNGLEDGEFLAGPOINTERPROC)(GLsizei stride, const void *pointer); +GLAPI PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer; +#define glEdgeFlagPointer glad_glEdgeFlagPointer +typedef void (APIENTRYP PFNGLENABLECLIENTSTATEPROC)(GLenum array); +GLAPI PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState; +#define glEnableClientState glad_glEnableClientState +typedef void (APIENTRYP PFNGLINDEXPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLINDEXPOINTERPROC glad_glIndexPointer; +#define glIndexPointer glad_glIndexPointer +typedef void (APIENTRYP PFNGLINTERLEAVEDARRAYSPROC)(GLenum format, GLsizei stride, const void *pointer); +GLAPI PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays; +#define glInterleavedArrays glad_glInterleavedArrays +typedef void (APIENTRYP PFNGLNORMALPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLNORMALPOINTERPROC glad_glNormalPointer; +#define glNormalPointer glad_glNormalPointer +typedef void (APIENTRYP PFNGLTEXCOORDPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer; +#define glTexCoordPointer glad_glTexCoordPointer +typedef void (APIENTRYP PFNGLVERTEXPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXPOINTERPROC glad_glVertexPointer; +#define glVertexPointer glad_glVertexPointer +typedef GLboolean (APIENTRYP PFNGLARETEXTURESRESIDENTPROC)(GLsizei n, const GLuint *textures, GLboolean *residences); +GLAPI PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident; +#define glAreTexturesResident glad_glAreTexturesResident +typedef void (APIENTRYP PFNGLPRIORITIZETEXTURESPROC)(GLsizei n, const GLuint *textures, const GLfloat *priorities); +GLAPI PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures; +#define glPrioritizeTextures glad_glPrioritizeTextures +typedef void (APIENTRYP PFNGLINDEXUBPROC)(GLubyte c); +GLAPI PFNGLINDEXUBPROC glad_glIndexub; +#define glIndexub glad_glIndexub +typedef void (APIENTRYP PFNGLINDEXUBVPROC)(const GLubyte *c); +GLAPI PFNGLINDEXUBVPROC glad_glIndexubv; +#define glIndexubv glad_glIndexubv +typedef void (APIENTRYP PFNGLPOPCLIENTATTRIBPROC)(void); +GLAPI PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib; +#define glPopClientAttrib glad_glPopClientAttrib +typedef void (APIENTRYP PFNGLPUSHCLIENTATTRIBPROC)(GLbitfield mask); +GLAPI PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib; +#define glPushClientAttrib glad_glPushClientAttrib +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture; +#define glClientActiveTexture glad_glClientActiveTexture +typedef void (APIENTRYP PFNGLMULTITEXCOORD1DPROC)(GLenum target, GLdouble s); +GLAPI PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d; +#define glMultiTexCoord1d glad_glMultiTexCoord1d +typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVPROC)(GLenum target, const GLdouble *v); +GLAPI PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv; +#define glMultiTexCoord1dv glad_glMultiTexCoord1dv +typedef void (APIENTRYP PFNGLMULTITEXCOORD1FPROC)(GLenum target, GLfloat s); +GLAPI PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f; +#define glMultiTexCoord1f glad_glMultiTexCoord1f +typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVPROC)(GLenum target, const GLfloat *v); +GLAPI PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv; +#define glMultiTexCoord1fv glad_glMultiTexCoord1fv +typedef void (APIENTRYP PFNGLMULTITEXCOORD1IPROC)(GLenum target, GLint s); +GLAPI PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i; +#define glMultiTexCoord1i glad_glMultiTexCoord1i +typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVPROC)(GLenum target, const GLint *v); +GLAPI PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv; +#define glMultiTexCoord1iv glad_glMultiTexCoord1iv +typedef void (APIENTRYP PFNGLMULTITEXCOORD1SPROC)(GLenum target, GLshort s); +GLAPI PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s; +#define glMultiTexCoord1s glad_glMultiTexCoord1s +typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVPROC)(GLenum target, const GLshort *v); +GLAPI PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv; +#define glMultiTexCoord1sv glad_glMultiTexCoord1sv +typedef void (APIENTRYP PFNGLMULTITEXCOORD2DPROC)(GLenum target, GLdouble s, GLdouble t); +GLAPI PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d; +#define glMultiTexCoord2d glad_glMultiTexCoord2d +typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVPROC)(GLenum target, const GLdouble *v); +GLAPI PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv; +#define glMultiTexCoord2dv glad_glMultiTexCoord2dv +typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC)(GLenum target, GLfloat s, GLfloat t); +GLAPI PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f; +#define glMultiTexCoord2f glad_glMultiTexCoord2f +typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVPROC)(GLenum target, const GLfloat *v); +GLAPI PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv; +#define glMultiTexCoord2fv glad_glMultiTexCoord2fv +typedef void (APIENTRYP PFNGLMULTITEXCOORD2IPROC)(GLenum target, GLint s, GLint t); +GLAPI PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i; +#define glMultiTexCoord2i glad_glMultiTexCoord2i +typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVPROC)(GLenum target, const GLint *v); +GLAPI PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv; +#define glMultiTexCoord2iv glad_glMultiTexCoord2iv +typedef void (APIENTRYP PFNGLMULTITEXCOORD2SPROC)(GLenum target, GLshort s, GLshort t); +GLAPI PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s; +#define glMultiTexCoord2s glad_glMultiTexCoord2s +typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVPROC)(GLenum target, const GLshort *v); +GLAPI PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv; +#define glMultiTexCoord2sv glad_glMultiTexCoord2sv +typedef void (APIENTRYP PFNGLMULTITEXCOORD3DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r); +GLAPI PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d; +#define glMultiTexCoord3d glad_glMultiTexCoord3d +typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVPROC)(GLenum target, const GLdouble *v); +GLAPI PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv; +#define glMultiTexCoord3dv glad_glMultiTexCoord3dv +typedef void (APIENTRYP PFNGLMULTITEXCOORD3FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r); +GLAPI PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f; +#define glMultiTexCoord3f glad_glMultiTexCoord3f +typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVPROC)(GLenum target, const GLfloat *v); +GLAPI PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv; +#define glMultiTexCoord3fv glad_glMultiTexCoord3fv +typedef void (APIENTRYP PFNGLMULTITEXCOORD3IPROC)(GLenum target, GLint s, GLint t, GLint r); +GLAPI PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i; +#define glMultiTexCoord3i glad_glMultiTexCoord3i +typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVPROC)(GLenum target, const GLint *v); +GLAPI PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv; +#define glMultiTexCoord3iv glad_glMultiTexCoord3iv +typedef void (APIENTRYP PFNGLMULTITEXCOORD3SPROC)(GLenum target, GLshort s, GLshort t, GLshort r); +GLAPI PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s; +#define glMultiTexCoord3s glad_glMultiTexCoord3s +typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVPROC)(GLenum target, const GLshort *v); +GLAPI PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv; +#define glMultiTexCoord3sv glad_glMultiTexCoord3sv +typedef void (APIENTRYP PFNGLMULTITEXCOORD4DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +GLAPI PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d; +#define glMultiTexCoord4d glad_glMultiTexCoord4d +typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVPROC)(GLenum target, const GLdouble *v); +GLAPI PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv; +#define glMultiTexCoord4dv glad_glMultiTexCoord4dv +typedef void (APIENTRYP PFNGLMULTITEXCOORD4FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +GLAPI PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f; +#define glMultiTexCoord4f glad_glMultiTexCoord4f +typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVPROC)(GLenum target, const GLfloat *v); +GLAPI PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv; +#define glMultiTexCoord4fv glad_glMultiTexCoord4fv +typedef void (APIENTRYP PFNGLMULTITEXCOORD4IPROC)(GLenum target, GLint s, GLint t, GLint r, GLint q); +GLAPI PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i; +#define glMultiTexCoord4i glad_glMultiTexCoord4i +typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVPROC)(GLenum target, const GLint *v); +GLAPI PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv; +#define glMultiTexCoord4iv glad_glMultiTexCoord4iv +typedef void (APIENTRYP PFNGLMULTITEXCOORD4SPROC)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +GLAPI PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s; +#define glMultiTexCoord4s glad_glMultiTexCoord4s +typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVPROC)(GLenum target, const GLshort *v); +GLAPI PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv; +#define glMultiTexCoord4sv glad_glMultiTexCoord4sv +typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXFPROC)(const GLfloat *m); +GLAPI PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf; +#define glLoadTransposeMatrixf glad_glLoadTransposeMatrixf +typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXDPROC)(const GLdouble *m); +GLAPI PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd; +#define glLoadTransposeMatrixd glad_glLoadTransposeMatrixd +typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXFPROC)(const GLfloat *m); +GLAPI PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf; +#define glMultTransposeMatrixf glad_glMultTransposeMatrixf +typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXDPROC)(const GLdouble *m); +GLAPI PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd; +#define glMultTransposeMatrixd glad_glMultTransposeMatrixd +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLFOGCOORDFPROC)(GLfloat coord); +GLAPI PFNGLFOGCOORDFPROC glad_glFogCoordf; +#define glFogCoordf glad_glFogCoordf +typedef void (APIENTRYP PFNGLFOGCOORDFVPROC)(const GLfloat *coord); +GLAPI PFNGLFOGCOORDFVPROC glad_glFogCoordfv; +#define glFogCoordfv glad_glFogCoordfv +typedef void (APIENTRYP PFNGLFOGCOORDDPROC)(GLdouble coord); +GLAPI PFNGLFOGCOORDDPROC glad_glFogCoordd; +#define glFogCoordd glad_glFogCoordd +typedef void (APIENTRYP PFNGLFOGCOORDDVPROC)(const GLdouble *coord); +GLAPI PFNGLFOGCOORDDVPROC glad_glFogCoorddv; +#define glFogCoorddv glad_glFogCoorddv +typedef void (APIENTRYP PFNGLFOGCOORDPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer; +#define glFogCoordPointer glad_glFogCoordPointer +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue); +GLAPI PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b; +#define glSecondaryColor3b glad_glSecondaryColor3b +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BVPROC)(const GLbyte *v); +GLAPI PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv; +#define glSecondaryColor3bv glad_glSecondaryColor3bv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue); +GLAPI PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d; +#define glSecondaryColor3d glad_glSecondaryColor3d +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DVPROC)(const GLdouble *v); +GLAPI PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv; +#define glSecondaryColor3dv glad_glSecondaryColor3dv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue); +GLAPI PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f; +#define glSecondaryColor3f glad_glSecondaryColor3f +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FVPROC)(const GLfloat *v); +GLAPI PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv; +#define glSecondaryColor3fv glad_glSecondaryColor3fv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IPROC)(GLint red, GLint green, GLint blue); +GLAPI PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i; +#define glSecondaryColor3i glad_glSecondaryColor3i +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IVPROC)(const GLint *v); +GLAPI PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv; +#define glSecondaryColor3iv glad_glSecondaryColor3iv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue); +GLAPI PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s; +#define glSecondaryColor3s glad_glSecondaryColor3s +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SVPROC)(const GLshort *v); +GLAPI PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv; +#define glSecondaryColor3sv glad_glSecondaryColor3sv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue); +GLAPI PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub; +#define glSecondaryColor3ub glad_glSecondaryColor3ub +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBVPROC)(const GLubyte *v); +GLAPI PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv; +#define glSecondaryColor3ubv glad_glSecondaryColor3ubv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue); +GLAPI PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui; +#define glSecondaryColor3ui glad_glSecondaryColor3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIVPROC)(const GLuint *v); +GLAPI PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv; +#define glSecondaryColor3uiv glad_glSecondaryColor3uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue); +GLAPI PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us; +#define glSecondaryColor3us glad_glSecondaryColor3us +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USVPROC)(const GLushort *v); +GLAPI PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv; +#define glSecondaryColor3usv glad_glSecondaryColor3usv +typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer; +#define glSecondaryColorPointer glad_glSecondaryColorPointer +typedef void (APIENTRYP PFNGLWINDOWPOS2DPROC)(GLdouble x, GLdouble y); +GLAPI PFNGLWINDOWPOS2DPROC glad_glWindowPos2d; +#define glWindowPos2d glad_glWindowPos2d +typedef void (APIENTRYP PFNGLWINDOWPOS2DVPROC)(const GLdouble *v); +GLAPI PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv; +#define glWindowPos2dv glad_glWindowPos2dv +typedef void (APIENTRYP PFNGLWINDOWPOS2FPROC)(GLfloat x, GLfloat y); +GLAPI PFNGLWINDOWPOS2FPROC glad_glWindowPos2f; +#define glWindowPos2f glad_glWindowPos2f +typedef void (APIENTRYP PFNGLWINDOWPOS2FVPROC)(const GLfloat *v); +GLAPI PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv; +#define glWindowPos2fv glad_glWindowPos2fv +typedef void (APIENTRYP PFNGLWINDOWPOS2IPROC)(GLint x, GLint y); +GLAPI PFNGLWINDOWPOS2IPROC glad_glWindowPos2i; +#define glWindowPos2i glad_glWindowPos2i +typedef void (APIENTRYP PFNGLWINDOWPOS2IVPROC)(const GLint *v); +GLAPI PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv; +#define glWindowPos2iv glad_glWindowPos2iv +typedef void (APIENTRYP PFNGLWINDOWPOS2SPROC)(GLshort x, GLshort y); +GLAPI PFNGLWINDOWPOS2SPROC glad_glWindowPos2s; +#define glWindowPos2s glad_glWindowPos2s +typedef void (APIENTRYP PFNGLWINDOWPOS2SVPROC)(const GLshort *v); +GLAPI PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv; +#define glWindowPos2sv glad_glWindowPos2sv +typedef void (APIENTRYP PFNGLWINDOWPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLWINDOWPOS3DPROC glad_glWindowPos3d; +#define glWindowPos3d glad_glWindowPos3d +typedef void (APIENTRYP PFNGLWINDOWPOS3DVPROC)(const GLdouble *v); +GLAPI PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv; +#define glWindowPos3dv glad_glWindowPos3dv +typedef void (APIENTRYP PFNGLWINDOWPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLWINDOWPOS3FPROC glad_glWindowPos3f; +#define glWindowPos3f glad_glWindowPos3f +typedef void (APIENTRYP PFNGLWINDOWPOS3FVPROC)(const GLfloat *v); +GLAPI PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv; +#define glWindowPos3fv glad_glWindowPos3fv +typedef void (APIENTRYP PFNGLWINDOWPOS3IPROC)(GLint x, GLint y, GLint z); +GLAPI PFNGLWINDOWPOS3IPROC glad_glWindowPos3i; +#define glWindowPos3i glad_glWindowPos3i +typedef void (APIENTRYP PFNGLWINDOWPOS3IVPROC)(const GLint *v); +GLAPI PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv; +#define glWindowPos3iv glad_glWindowPos3iv +typedef void (APIENTRYP PFNGLWINDOWPOS3SPROC)(GLshort x, GLshort y, GLshort z); +GLAPI PFNGLWINDOWPOS3SPROC glad_glWindowPos3s; +#define glWindowPos3s glad_glWindowPos3s +typedef void (APIENTRYP PFNGLWINDOWPOS3SVPROC)(const GLshort *v); +GLAPI PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv; +#define glWindowPos3sv glad_glWindowPos3sv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ffi/gles3-export.c b/ffi/gles3-export.c new file mode 100644 index 0000000..2e32429 --- /dev/null +++ b/ffi/gles3-export.c @@ -0,0 +1,99 @@ +#include "export.h" +#include "glad.h" +#include +#include + +// OpenGL constants used below +unsigned int VERTEX_SHADER = GL_VERTEX_SHADER; +unsigned int FRAGMENT_SHADER = GL_FRAGMENT_SHADER; +unsigned int TRIANGLES = GL_TRIANGLES; +unsigned int TRIANGLE_FAN = GL_TRIANGLE_FAN; +unsigned int STATIC_DRAW = GL_STATIC_DRAW; +unsigned int DYNAMIC_DRAW = GL_DYNAMIC_DRAW; + +// OpenGL functions used below +void loadGlad() { + gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); +} + +void viewport(int width, int height) { + glViewport(0, 0, width, height); +} + +void clearColor(float r, float g, float b, float a) { + glClearColor(r, g, b, a); +} + +void clear() { + glClear(GL_COLOR_BUFFER_BIT); +} + +unsigned int createBuffer() { + unsigned int buffer; + glGenBuffers(1, &buffer); + return buffer; +} + +void bindBuffer(unsigned int buffer) { + glBindBuffer(GL_ARRAY_BUFFER, buffer); +} + +void bufferData(float* vector, int vectorLength, unsigned int updateMode) { + glBufferData(GL_ARRAY_BUFFER, sizeof(float) * vectorLength, vector, updateMode); +} + +unsigned int createShader(unsigned int shaderType) { + return glCreateShader(shaderType); +} + +void shaderSource(unsigned int shader, const char *sourceString) { + glShaderSource(shader, 1, &sourceString, NULL); +} + +void compileShader(unsigned int shader) { + glCompileShader(shader); +} + +void deleteShader(unsigned int shader) { + glDeleteShader(shader); +} + +void vertexAttribPointer(int location, int numVecComponents, int stride, int offset) { + glVertexAttribPointer(location, numVecComponents, GL_FLOAT, GL_FALSE, stride * sizeof(float), (void*)offset); +} + +void enableVertexAttribArray(int location) { + glEnableVertexAttribArray(location); +} + +unsigned int createProgram() { + return glCreateProgram(); +} + +void attachShader(unsigned int program, unsigned int shader) { + glAttachShader(program, shader); +} + +void linkProgram(unsigned int program) { + glLinkProgram(program); +} + +void useProgram(unsigned int program) { + glUseProgram(program); +} + +void deleteProgram(unsigned int program) { + glDeleteProgram(program); +} + +void drawArrays(unsigned int drawMode, int startIndex, int numVertices) { + glDrawArrays(drawMode, startIndex, numVertices); +} + +int getUniformLocation(unsigned int program, const char *uniformName) { + glGetUniformLocation(program, uniformName); +} + +void uniform4f(int uniformLocation, float a, float b, float c, float d) { + glUniform4f(uniformLocation, a, b, c, d); +} diff --git a/ffi/gles3-import.sml b/ffi/gles3-import.sml new file mode 100644 index 0000000..d876cea --- /dev/null +++ b/ffi/gles3-import.sml @@ -0,0 +1,58 @@ +structure Gles3 = +struct + type buffer = Word32.word + type shader_type = Word32.word + type shader = Word32.word + type program = Word32.word + type draw_mode = Word32.word + type update_mode = Word32.word + + (* OpenGL constants used. *) + val (VERTEX_SHADER, _) = + _symbol "VERTEX_SHADER" public : ( unit -> shader_type ) * ( shader_type -> unit ); + val (FRAGMENT_SHADER, _) = + _symbol "FRAGMENT_SHADER" public : ( unit -> shader_type ) * ( shader_type -> unit ); + val (TRIANGLES, _) = + _symbol "TRIANGLES" public : ( unit -> draw_mode ) * ( draw_mode -> unit ); + val (TRIANGLE_FAN, _) = + _symbol "TRIANGLE_FAN" public : ( unit -> draw_mode ) * ( draw_mode -> unit ); + val (STATIC_DRAW, _) = + _symbol "STATIC_DRAW" public : ( unit -> update_mode ) * ( update_mode -> unit ); + val (DYNAMIC_DRAW, _) = + _symbol "DYNAMIC_DRAW" public : ( unit -> update_mode ) * ( update_mode -> unit ); + + (* OpenGL functions used. *) + val loadGlad = _import "loadGlad" public : unit -> unit; + val viewport = _import "viewport" public : int * int -> unit; + + val createBuffer = _import "createBuffer" public : unit -> buffer; + val bindBuffer = _import "bindBuffer" public : buffer -> unit; + val bufferData = + _import "bufferData" public : Real32.real vector * int * update_mode -> unit; + + val createShader = _import "createShader" public : shader_type -> shader; + val compileShader = _import "compileShader" public : shader -> unit; + val deleteShader = _import "deleteShader" public : shader -> unit; + val shaderSource = _import "shaderSource" public : shader * string -> unit; + + val vertexAttribPointer = + _import "vertexAttribPointer" public : int * int * int * int -> unit; + val enableVertexAttribArray = + _import "enableVertexAttribArray" public : int -> unit; + + val createProgram = _import "createProgram" public : unit -> program; + val attachShader = _import "attachShader" public : program * shader -> unit; + val linkProgram = _import "linkProgram" public : program -> unit; + val useProgram = _import "useProgram" public : program -> unit; + val deleteProgram = _import "deleteProgram" public : program -> unit; + + val clearColor = + _import "clearColor" public : Real32.real * Real32.real * Real32.real * Real32.real -> unit; + val clear = _import "clear" public : unit -> unit; + val drawArrays = _import "drawArrays" public : draw_mode * int * int -> unit; + + val getUniformLocation = + _import "getUniformLocation" public : program * string -> int; + val uniform4f = + _import "uniform4f" public : int * Real32.real * Real32.real * Real32.real * Real32.real -> unit; +end diff --git a/ffi/glfw-export.c b/ffi/glfw-export.c new file mode 100644 index 0000000..0fc3eb9 --- /dev/null +++ b/ffi/glfw-export.c @@ -0,0 +1,43 @@ +#include +#define GLFW_INCLUDE_NONE +#include + +// GLFW constants used below +int CONTEXT_VERSION_MAJOR = GLFW_CONTEXT_VERSION_MAJOR; +int DEPRECATED = GLFW_DECORATED; +int GLFW_FFI_FALSE = GLFW_FALSE; +int SAMPLES = GLFW_SAMPLES; + +// GLFW functions used below +void init() { + glfwInit(); +} + +void windowHint(int hint, int value) { + glfwWindowHint(hint, value); +} + +GLFWwindow* createWindow(int width, int height, const char *title) { + return glfwCreateWindow(width, height, title, NULL, NULL); +} + +void terminate() { + glfwTerminate(); +} + +void makeContextCurrent(GLFWwindow* window) { + glfwMakeContextCurrent(window); +} + +bool windowShouldClose(GLFWwindow *window) { + glfwWindowShouldClose(window); +} + +void waitEvents() { + glfwWaitEvents(); +} + +void swapBuffers(GLFWwindow *window) { + glfwSwapBuffers(window); +} + diff --git a/ffi/glfw-import.sml b/ffi/glfw-import.sml new file mode 100644 index 0000000..f24f27c --- /dev/null +++ b/ffi/glfw-import.sml @@ -0,0 +1,25 @@ +structure Glfw = +struct + type window = MLton.Pointer.t + + (* Window hint constants. *) + val (CONTEXT_VERSION_MAJOR, _) = + _symbol "CONTEXT_VERSION_MAJOR" public : ( unit -> int ) * ( int -> unit ); + val (DEPRECATED, _) = + _symbol "DEPRECATED" public : ( unit -> int ) * ( int -> unit ); + val (FALSE, _) = + _symbol "GLFW_FFI_FALSE" public : ( unit -> int ) * ( int -> unit ); + val (SAMPLES, _) = + _symbol "SAMPLES" public : ( unit -> int ) * ( int -> unit ); + + (* GLFW functions. *) + val init = _import "init" public : unit -> unit; + val windowHint = _import "windowHint" public : int * int -> unit; + val createWindow = + _import "createWindow" public : int * int * string -> window; + val terminate = _import "terminate" public : unit -> unit; + val makeContextCurrent = _import "makeContextCurrent" public : window -> unit; + val windowShouldClose = _import "windowShouldClose" public : window -> bool; + val waitEvents = _import "waitEvents" public reentrant : unit -> unit; + val swapBuffers = _import "swapBuffers" public : window -> unit; +end diff --git a/ffi/glfw-input.c b/ffi/glfw-input.c new file mode 100644 index 0000000..d166824 --- /dev/null +++ b/ffi/glfw-input.c @@ -0,0 +1,8 @@ +#include "export.h" +#define GLFW_INCLUDE_NONE +#include + +int PRESS = GLFW_PRESS; +int REPEAT = GLFW_REPEAT; +int RELEASE = GLFW_RELEASE; + diff --git a/ffi/glfw-input.sml b/ffi/glfw-input.sml new file mode 100644 index 0000000..f83307d --- /dev/null +++ b/ffi/glfw-input.sml @@ -0,0 +1,12 @@ +structure Input = +struct + type window = MLton.Pointer.t + + (* Constants. *) + val (PRESS, _) = + _symbol "PRESS" public : ( unit -> int ) * ( int -> unit ); + val (REPEAT, _) = + _symbol "REPEAT" public : ( unit -> int ) * ( int -> unit ); + val (RELEASE, _) = + _symbol "RELEASE" public : ( unit -> int ) * ( int -> unit ); +end diff --git a/ffi/khrplatform.h b/ffi/khrplatform.h new file mode 100644 index 0000000..975bbff --- /dev/null +++ b/ffi/khrplatform.h @@ -0,0 +1,282 @@ +#ifndef __khrplatform_h_ +#define __khrplatform_h_ + +/* +** Copyright (c) 2008-2018 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* Khronos platform-specific types and definitions. + * + * The master copy of khrplatform.h is maintained in the Khronos EGL + * Registry repository at https://github.com/KhronosGroup/EGL-Registry + * The last semantic modification to khrplatform.h was at commit ID: + * 67a3e0864c2d75ea5287b9f3d2eb74a745936692 + * + * Adopters may modify this file to suit their platform. Adopters are + * encouraged to submit platform specific modifications to the Khronos + * group so that they can be included in future versions of this file. + * Please submit changes by filing pull requests or issues on + * the EGL Registry repository linked above. + * + * + * See the Implementer's Guidelines for information about where this file + * should be located on your system and for more details of its use: + * http://www.khronos.org/registry/implementers_guide.pdf + * + * This file should be included as + * #include + * by Khronos client API header files that use its types and defines. + * + * The types in khrplatform.h should only be used to define API-specific types. + * + * Types defined in khrplatform.h: + * khronos_int8_t signed 8 bit + * khronos_uint8_t unsigned 8 bit + * khronos_int16_t signed 16 bit + * khronos_uint16_t unsigned 16 bit + * khronos_int32_t signed 32 bit + * khronos_uint32_t unsigned 32 bit + * khronos_int64_t signed 64 bit + * khronos_uint64_t unsigned 64 bit + * khronos_intptr_t signed same number of bits as a pointer + * khronos_uintptr_t unsigned same number of bits as a pointer + * khronos_ssize_t signed size + * khronos_usize_t unsigned size + * khronos_float_t signed 32 bit floating point + * khronos_time_ns_t unsigned 64 bit time in nanoseconds + * khronos_utime_nanoseconds_t unsigned time interval or absolute time in + * nanoseconds + * khronos_stime_nanoseconds_t signed time interval in nanoseconds + * khronos_boolean_enum_t enumerated boolean type. This should + * only be used as a base type when a client API's boolean type is + * an enum. Client APIs which use an integer or other type for + * booleans cannot use this as the base type for their boolean. + * + * Tokens defined in khrplatform.h: + * + * KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values. + * + * KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0. + * KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0. + * + * Calling convention macros defined in this file: + * KHRONOS_APICALL + * KHRONOS_APIENTRY + * KHRONOS_APIATTRIBUTES + * + * These may be used in function prototypes as: + * + * KHRONOS_APICALL void KHRONOS_APIENTRY funcname( + * int arg1, + * int arg2) KHRONOS_APIATTRIBUTES; + */ + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(_WIN32) && !defined(__SCITECH_SNAP__) +# define KHRONOS_APICALL __declspec(dllimport) +#elif defined (__SYMBIAN32__) +# define KHRONOS_APICALL IMPORT_C +#elif defined(__ANDROID__) +# define KHRONOS_APICALL __attribute__((visibility("default"))) +#else +# define KHRONOS_APICALL +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIENTRY + *------------------------------------------------------------------------- + * This follows the return type of the function and precedes the function + * name in the function prototype. + */ +#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__) + /* Win32 but not WinCE */ +# define KHRONOS_APIENTRY __stdcall +#else +# define KHRONOS_APIENTRY +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIATTRIBUTES + *------------------------------------------------------------------------- + * This follows the closing parenthesis of the function prototype arguments. + */ +#if defined (__ARMCC_2__) +#define KHRONOS_APIATTRIBUTES __softfp +#else +#define KHRONOS_APIATTRIBUTES +#endif + +/*------------------------------------------------------------------------- + * basic type definitions + *-----------------------------------------------------------------------*/ +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__) + + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(__VMS ) || defined(__sgi) + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(_WIN32) && !defined(__SCITECH_SNAP__) + +/* + * Win32 + */ +typedef __int32 khronos_int32_t; +typedef unsigned __int32 khronos_uint32_t; +typedef __int64 khronos_int64_t; +typedef unsigned __int64 khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(__sun__) || defined(__digital__) + +/* + * Sun or Digital + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#if defined(__arch64__) || defined(_LP64) +typedef long int khronos_int64_t; +typedef unsigned long int khronos_uint64_t; +#else +typedef long long int khronos_int64_t; +typedef unsigned long long int khronos_uint64_t; +#endif /* __arch64__ */ +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif 0 + +/* + * Hypothetical platform with no float or int64 support + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#define KHRONOS_SUPPORT_INT64 0 +#define KHRONOS_SUPPORT_FLOAT 0 + +#else + +/* + * Generic fallback + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#endif + + +/* + * Types that are (so far) the same on all platforms + */ +typedef signed char khronos_int8_t; +typedef unsigned char khronos_uint8_t; +typedef signed short int khronos_int16_t; +typedef unsigned short int khronos_uint16_t; + +/* + * Types that differ between LLP64 and LP64 architectures - in LLP64, + * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears + * to be the only LLP64 architecture in current use. + */ +#ifdef _WIN64 +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +typedef signed long int khronos_ssize_t; +typedef unsigned long int khronos_usize_t; +#endif + +#if KHRONOS_SUPPORT_FLOAT +/* + * Float type + */ +typedef float khronos_float_t; +#endif + +#if KHRONOS_SUPPORT_INT64 +/* Time types + * + * These types can be used to represent a time interval in nanoseconds or + * an absolute Unadjusted System Time. Unadjusted System Time is the number + * of nanoseconds since some arbitrary system event (e.g. since the last + * time the system booted). The Unadjusted System Time is an unsigned + * 64 bit value that wraps back to 0 every 584 years. Time intervals + * may be either signed or unsigned. + */ +typedef khronos_uint64_t khronos_utime_nanoseconds_t; +typedef khronos_int64_t khronos_stime_nanoseconds_t; +#endif + +/* + * Dummy value used to pad enum types to 32 bits. + */ +#ifndef KHRONOS_MAX_ENUM +#define KHRONOS_MAX_ENUM 0x7FFFFFFF +#endif + +/* + * Enumerated boolean type + * + * Values other than zero should be considered to be true. Therefore + * comparisons should not be made against KHRONOS_TRUE. + */ +typedef enum { + KHRONOS_FALSE = 0, + KHRONOS_TRUE = 1, + KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM +} khronos_boolean_enum_t; + +#endif /* __khrplatform_h_ */ diff --git a/shell/shell.sml b/shell/shell.sml new file mode 100644 index 0000000..8f60106 --- /dev/null +++ b/shell/shell.sml @@ -0,0 +1,34 @@ +structure Shell = +struct + open CML + + fun loop window = + case Glfw.windowShouldClose window of + false => + let + val _ = Gles3.clearColor (0.1, 0.1, 0.1, 0.1) + val _ = Gles3.clear () + + val _ = Glfw.swapBuffers window + val _ = Glfw.waitEvents () + in + loop window + end + | true => Glfw.terminate () + + fun main () = + let + (* Set up GLFW. *) + val _ = Glfw.init () + val _ = Glfw.windowHint (Glfw.CONTEXT_VERSION_MAJOR (), 3) + val _ = Glfw.windowHint (Glfw.DEPRECATED (), Glfw.FALSE ()) + val _ = Glfw.windowHint (Glfw.SAMPLES (), 4) + val window = Glfw.createWindow (1600, 900, "shf") + val _ = Glfw.makeContextCurrent window + val _ = Gles3.loadGlad () + in + loop window + end +end + +val _ = RunCML.doit (Shell.main, NONE) diff --git a/shf b/shf new file mode 100755 index 0000000000000000000000000000000000000000..821dd0fd32385cf85a98aa60259f640a8a92bc17 GIT binary patch literal 837688 zcmeFaeSB2awg128Oh8n$AP9&^P9}&J6%_-5wQ?8`A8NgdQ|lu+nUDy|lLQp2ttW$8 ztKODTYOUU@lUS`%+tOCl*r!Rb)@o}FwqC#XX%c+8(%XVo%~+Fs-|IYNb{-~7fA{zL z{&nyb&spo7v-jGcz4lsbuf5Ni8&5xHu@Q-=;GdzMR6=D(EpSp+~#IT@*w&b7=cmH2F1`^6qo-6#b z{8R6ko92H+TcmtOr$zvFX@T~dvC&ij4C2j9=U{h6N?G zB?q<0{eR&o_sYNX-dMj(&Np`N@6sE)&+2!4%ydZ=9E0c1=Q)wH)PH0A8<+U?6~pC( zqr4k~W6)d2uUwHle&w>`R<2mRVdHT%HS21Z W(ux93oUc1NhnDoRM=YCF&y>rX}G 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

llZG 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

#xC`2zW5 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

xnad{P8 zv>U)3f%EXBamS!-W3L3?cDpXjRJ4S9XtSSIX~^+ui2J7HS~}{1A^ULX46>oDes^5I+rIK~5nH~3H?&%@<+h1Q?6@gvCNQbl(H z%h2$*<%{Jw@_zVqEz2D0Ew3LI=LUOlrc&zM>W6>!L5xpeYojvaw<#lhr_1PAofi8u z*kd{FvTX?4kqxH}adkbj;j}q%eLeEL{_@wV-VU2r@7!Q}xiPPQWAcjjjtw`iaVZ-@ zTW<0Sf9^8mbulJ+PN&t7S8byj@(LT3nOES)c}U+@C z7opo9?X?+;?SQO21I#goJRjAX?&Hr5+OBKV$sbcEz;)19*?k^;Z;f0P$|d=Aa6O%J z9WwHS;J8umYZ$t$JboB?Tsd4G#e!hX z2O9G@4|(LeDAzr?4%&gS9lu2(yvyu|JjlLL!uCh7ae#5{lxw7<+lajK+oszG-6&X0 zw*oNkwby|QeI1f*s5U$Bb-h}Ge6(0Pa$Z!rp&ephRHN>*%0%m$a?15v;F$GWc`t~u zcbEg1w8@8j&Act1t0ddp0Q)pu=k(fbZ?U`}==@+xpWd9{#Xr__8mwKhj@tNZ()j+I zpbz-za@}p!-NDyno9;Jl+LZm*SnnVceC?{#3;bDBA05t#bop~l%Ra*yqx|-70E}}H zlct07&1@GA{3;EMw#a$382xXWk2l8AFVhY{cM{*%<-vAF`aibLbn$=OrnN2)(`P)c zWxbqrL-t4Uova+A5|+4+Rm1GNSbff4fahEHvxc1K09LVJ$ftzWELeqe8sLQ%40Th& zgcHkBM*Sn6Yr$&JJz<^&a{-I`asQ0SZhl(lbFx(?NBs_EQdo$3OnISeFI5)kKeq|Y zLs_qrWufgW?5ZhiQ=eFl#$H|xdCnoNENj>wq`|sefqo-8oS&yH9Y;L0Bf+s8@Y=B! zv(fMZ9QP}1lktM>7`y-@uP%&}4KLiaDAQnDG%!&+P5Lf!9H-VBfTPz$Aaj&fiDzSx zu0#G@6QO@F{-1(84BM`;{)M!9tBvUuJU=ordu23`ht-Q`~3;I9(?O^ z?Kl#-YUc$5A8V9rt&t193kkV)ymh%Y9f@4-!eGsYM!7nTT-YN{$kqMU<+}PvM%`+ku<5*S1aky2|USGgN;h)0guYi@)xVyB(YpDeLiO zkETPPG;ssQo(QGCnLzxhfYq_?p0_Wc*X>mwV%F{TIE8W&|$i*bi7qo4jt*@Cw- zkGftRNg4e})3IzH!I;R_*V%ym54Dee@J*CaM@|`?XyJ*qowA*KupP48T$CHjYaZ5S zuzy?P{;e)YuH{8IcG+U@sbQ>>SGN8ILED{;WqVCl*#fsSjf=8f9hX7n+{zMV7y?rBdihrkF}%m;AP}b_cL~y zMc_%@VsH0|bn7h+w*N(=ZYx>31@4|SE_D0nhtcgn{ZiSek?OWr(^0o~{Qsm|QOwkB zX5U^}9JKvqqkflX=@+=2X#`=^carh5C#JG=#Z|QFWoKtaE%w*gZGX;0WoQ6AITAFK+t+wQR z$b13rj9Cnsmq6yFkhvW)pE?QnQ-JRRe;V*-0)Gzhk(UdQm&M4-669qm^3smHoHh?Q z^MSLlwnX&3^WYNXZ7K5Bj=Z_Z*A?mdME@-1M-|m4`cc_+PWyC4@kip*CG(3jpc7C( z^gJk{r|;NX#vjx;8fJi%9E>Xq$R3pvJa||8GZKm1*MJp+8pp z+m(+1(&0Df-Cx7GHy2~=Lm$T-IK>n79XRoty*CG{J|bNRo~bTdKsS&X+VJ1g(`J%WBOsn?vj ze6!WYh8bh6;y$(}Y)HtlTG^F>*D2JZGWF7&+UFnV62 z^wqy;gnC}B>1Km&Zc@+vZv*UqNYDN3FHJoeM$i36Q-03-w4NLKY`|lktM|fr&M!R< zlX?%K_rGb>`+uy-sNcZdp2mgVUm&hEe>Z&hq;bQ!K_74nqtx9nqzMmGX8-w$Y8&$W z`Uu*_Pc_|}(A6G{N9?wNPJQHMHXHV2wp<&Lb8xNmRsWGHvo6l#foJxp4Bm?@Gtwu^ zY}F3{AG$_V*IM!N{*7z==>83BA4vMvJJ<^(FL_>ozNx%_WQuo}xv!%|c)R2t63$h( zinf-2AKTs{|Kl7r|GzZ5y#@E(C>#mHdv+W*k(d6z+x(Y2@RkMs56$p)9h~a6yaV=@ zZKysLl1biaLS9S{_pWp?U(_AeL85e_JMzSRX^SFynijyL;3KV_nZ6z_o%YGu46vHhvn(;juX4QW}vRj&}rf<1msj{VqHzbv&xJ3c6sr? zU0&^Cm(#qoC2aS0eI0G6)pJ{%<}+Ku3*DBJyVQTSr#j>)HDla(OX;zNl+nlmpFWI> zc%D_&7kyuieCNr)sOt-nSL$aXWL=ih^@XvnL-x6LdXR-_PG*`3_)-byI#whL%Av&Z zGt*%?nDliy$g&bMT83UI{n4AKtF7Su(gmo)HeaOGP(HXb=0kYjSoQD!Tc2Hz{jjC| z0}qa4qj`eY9t=F1vVZ>E;D14<#uh^!+2(tYXERUu-p|!NR|dyffqZ~B_jF^wtvGFi zXL#+lcs&MQ0`m{9*+qCOS$`UN{c5Z@6yaoyB_0B=)_r0w*F`R9Q+LBf_?&M&auH+{ zPq*Ui@2_6y`sCYz(<-k0^3W;p4Tm52ug3DN-sD-iUvq69Zv#hsGW2l=(rrVUZ{n@r zA^fCo4Q&R#4^Az&>_dL}9b$~w^7^tvJa}$AP==)ZGQ<3`pevsKz=OI=foypY!@( zmh87W4o`cjMf;jXJM@H5_pleCyV0l{99!XDs8H{z%Qu|ZhvO}%64!0{jdggG%~g; zXrzy_jMx7ee}XC}l^*$me>?B}1D{9^4JW=C3&M^lIS>*Ky(GundJZqpe%LO{;OC+a z;CrI0&juE5f!_2RK3of6-zxQq{FBD?u~J5y&y?qLa7Sd(Z4U}X%Gtoo422Rwu;o<$wI!_fRGXwv$2-~%7=r%w-j zY|dfb<`{u~^{5B!@agG-?~lRDJZl5|GU}nh8T~x!D8?prj7N?_`ThiNxb4IEq=;|a zSH4R28=wg-no*A+J*=UyZa2aH1Ghgq%LCksgu>x?Y%V?}nJ1Qtl^tnEpXzTZ0qwNX$e`mQE zR6LV?s64+1+dKdp;>=OLi5I;LIz8v6j69P-Tg7t(4*dW5EzhArj#HTi{>SsWcx=JE zP)^Tkd(K+a7rHh+B!8e(1XWc}60lKPR z=2xYEgubVeb=gB*XF1CIe^3X+7-^%=@@d;qX6C&{!cqS(L0PRA5Bl$uZJ2eQZz7}4 zbNtA@9`-$^#eV}oEG@fKO`6YZaVUy!GHmtUTF|?dpq8{C9-P0?_i5Ty3ZZa@h4DRK4u@ySvV z_6G5U?cVvhRXsa*e#F^Oy0`R3`8lznb%HD_j4K`bZphH9h8SyEyOE6Zpn<)Eymk zzAa@(YlYzAKT_=+xUv0*43vp!ItM$2JLo5v4)bYX9Dl@f88w!V z;xhQYPxGaZZ-fWFOuq~13#89F8O4D=bc8g_9oa{8oeW0Dlekd!yJyw3_L#`8b zTd;kKqkgG8THf0fruwD-{KI%GRlISyvlrS6;p$#|_9SXo8Ex~Ukb~_{uIHhA&A5qmE@}tv z(LvkUjk26W{h}_!W2ZPx+TC=zcH6rg>B_yYyfpozgEhF*CtW8`(rMD>JD$i)JDu)s ztIeOM^UJ*#mUTvc`-c*Ql}RZMYwX z{a(oRMuwbcGUQyxw1rJ9;RK6 z4Yqr!a!0%TXXc%C-7f~8e8Xx3KIK>N!?pp?#%&;$InxG(V}n9xN)E3n_zLA1tLg*W zneJb3Kjzq=EsgIt1@{_!j0F?*8~B}R{903Rr@^<*Ov?5J{55HOcT{kj!N;68&3{uG z-yap+4E%H%+3m4{x_#Dg<->eln9>W%r_0EJc0#?dT^c=M{ce_ObEBd*cRSLd|D7y5 z{XT3LXpC$HQ?5e44{O;ry{04kDZV3HM|l|A7uQX*#;?addLHF*p1^u8=TRN&J$?Ss zg)OM*wODih5x5b|oPR7^urlY2;Nx4c8uCC`#e%tj4FD!};EfB&gLdcb(1E}=*AUV) zEEAb8(AAF@+de^E>G8Hh-OBO&xS*!r#X4K_`Y7>0)9QDu@8O;v@Pt1;_$!tV+d1^e zdQ#)QqqKwL1Hv{UJ}NiTh+~6p1v|j8C1s|5INy}xEYf<%O4^TTTGJLp`Pe}7JK%%X zw`h%Qb;`#4G^zKr+c56v+_wztrYargoqbt5^20Y9IL>l`wfz&;1oQ8|C%+yQBV=PM83jw+dd|JX=}^}TAJis`X#W~C?4hq0`{ z;|5b-4<{4HOH$?xIrhTmNXp?J7s>HBu4Z!v@AFkFn^Yj0z-hW2R%Cp$%df%nX?j*zwp}w-NMdd&{ugg7A4w{B@e%56{ zJ%bi&h}?US<-Hf>Eu>DBU7*fI4LUDggSlTc$BoC89M{&~A#ItdPZ#5z1j-_Hi?_;K z(T>=*4UF%Xn{U27ZxkaHGy;8s059;POV$BZppS{)>PQuYRy3n zd7$lBpmm6QmSdTaW&!lFK6%H>cPYM{l_un}Wf1FBnx_3amE)syrXZd1c&}O@-J{cK zflj97pAaCvpY1Q43L7&u*%vwPgoxi5@WaB0megyfkUY znf|}q>A3I-)am>{^701vApEvYZ#UB8n($W z^R9Rf49D~JW2$JlN3Kr~@A_aL^1H+FJa`Q4_mT7D+d<&@=x{vWIHo#lBs>M)?*Y#T zhT|#5R!=-~p13zp@%)13iTcR8)GO_ksY^{`lk3!IA7+jE+MlB@Lj4?%I^955JBGGV z@^WTMJE!=1v*o+=F50Y%x*D&eMSWJ3zOik!lw5@0$afayew*sAXYEckm7jz(wu$Rh6xeN_r3PlBZ#>^3FKm zg^$O0zQ(g*4{Mm;Y2oo5L(tl=8^>yX<&9CgWsMgu|8xWsc-wF#%9pZ>IpX+MPpsd< z_YSdUQ|g`*xL1}R?GmEdeagjtZ0iqTYkLLWeR?}-_#I9Pu*agl@pcpIw1ne*q{ZeN z?;b5O-`?av`Vo^B_cEMg;FT$X94iry`{d7v;4J~`wB%WC4Q7~c+{2GOTrGnO8)ech z1uf>=Z3`xw@5nD293h_Ns4zm3w* z$m_p{s*cFHFvgL{hgnPRE%Kh{wv_(DGlL5BXV&WVSW4m+rlxSqbAvwzu7`5$O6qVG z+eRc8Y__Qb4#y+ZE&QZwpyL?u@3oAq7lx)d2lv8bTyO4G;aDoxLE}EaUaWDmtP=Ud zJ)e7~r(~|p3)V7!3YX(YRUR3-yAyJG*iZLZA29yT*q7?%U8397K3}h6+LAacxQuC} z^-X!wxX|}ST8GV+4w-J7r4NpwhSTA7khKOH>Rry!CUsU>XF0A{bvb^&^u53}{Q+%~ z(LvKZyiEbU$otDU$AtX8)VuK=vDzbj@RY4E^$BbBM+e(SX?^4VJ*F!v=LX}HF1ROd z-h{DblXQF1bm6(dn^!-af#8`c*JawJ|lm-i>~e_kGeXp)Z54l88-l+!?YvB9 zwoZrlMS z=<7!7jRmA##DCu1YIMf7q|!A0J4cXa?dYH|wlU2=XPPJr)-|5lMw#~&f!o%AyCC=+ zakZbHjoX>V4HpETGI?2-$_xIFBrnvxWfS^}?lHk8SatMTlaIVQ3cBrSI`_Qb zawDgos-yUC^vyatoW2`m#GcN;_(olye>fRIS2#9BCl&^CjEtL8GUES{$~e&I7m9X^ zwcO)U>7l(h8#(Pd0o+XuxC??)-;;BHUjqE7tR<-kRGiY=)+f&WKZC(xhnLcf`K z7em%rAM51DH|FKXNYm`gMEgp>ZA;^Z3xj@*Yws)Z{V2n~GfjhgjlNA9yn(?pCpP~z zXwkCDv;6M7-U1+;f7qo+Ub+n;=igCf76MQv(wA#>J zCaqgkS{2wq(mMFha71a8#~DAwL_57zry%lY1qgP1uHTT(IfH z#(Z6^)8v@UnJE&!k3$zujL&MLkEp}8qpb|?#h&Coj!7_XNTlJ75B8j#O2a)rxR7bE zf3e#Pa0k-3l?A~<;j-1JhMn{LOs>5}UWPQjV! z({N_GMW6F_T)E%gt@i5Oz$q7>4X2(EECKCO(6)oNG|3x04RkG_>Sssh&dP6+n@YjXZ_J@Vr`ys_WK zTxHvj!Q(RpjuWMf4*jV=(@CF|2v+C+$KW51uns*r^N|j}k*2c{b>fMOI>jQqiY>(dUQUiYvL;{Voyb?+tq%QMXvVx6?e_3mhn ztm}_z6Qo5xq#xavA;*m<&%$VR9@FSqV6EU|s%=PG+7qdhnevQ)hHX`_IW`P))_L*& z*7>8W1=KmDw<_XY9vfVn;_d7&L}kphoYzzT52pUVk@_!+N&0cA|IP7#NA#|8o{#C} z{}i>P#fB1De73)9wJsAI&ay%9P zhYnA0%A>8l9z8C_92Y)&QT~k`v&(rJ%K1U8>vJE*6Q5h;$QHfRf?yR`CxhIKc|bLg*PeB2c< zbC$+;7iZ!l{Szc_oC|$wromm3i7N`5B6)9|q4MC07fC8**p5PVQX2Mfp*kTA>n&7|O~W23RP`QG zEX$*XY7_9V?kxLdb1wjF;4CAv^H`z!-|T0H!$Es^?Ql5H6skW1j^QiySSwWb9ggnF zLiL5i;lNJy9}eeWq598rHtin|htpK7{>|ZV#uTf6eK;K0+xvi%(Ao2a z>KD_n7Yo(94#&$qs`}Z(;Y>TK>K_j0%F)%E4~H|USe1Td!_^ts^7kK(5BiI%4~K(3 z3VuX*YO%Dqa|SLL~X*gS{F1_K?9X&;4@3R3=V66z z_>6E447i8-$@Z!Bly1uVTMimuZ|=KLz<{$7NZ-&yaggq}Tg}-9@Ye72Xl+ zNR~0m;b;rnqI-O>=AG#@ z76g;1v*en+#NCv}#rorTOP;K9TX48?gA8q#rDZrb`0Zt?++<(C^){3b`cApt7M0(F zjpdhX-=^XnS&Yy2VV%LyXUTgEb-wF>{z3`Pg7pnM4k(VzjcT^4)`6?E@)c` z=NJXo>$-b+4+7gXZ3FJR@U^}A+4DnRlzuT7r%8VFf#z75{K%Vd@VJA#^%$CWU&;AD z__f1+z_)KT=Z%zu|5@gH@jn{NdW9&x?;<_eLAkG72fbV$M0>4+*5UdfzmcZH^+A4v zkHhsre4BPvr!4%>bK{V$jQ>W@qjumtBWU)5#{hUT4dPZ3?Jau`dVu>EBD8rLlb*8tbZCo=5K7U)F!BW3r|-9^Z-$KqRK9|!w)v8uOm zJ)k_M9_W0?^>-~N_k_$lP0R<@$D?w&9x_bQby2nhuEUykz;#&5uJus={IB)zTKX?O z+}KY3U)i|@$iuMxNcn_d&->!CGx_6}#~BA@8r`?=rY>dPCL7o4oyP{z66 z?qcnPU=7|YWd5Qt5$ek>E1#oqm&)(+-0yJmKLh!PEhqR!ueqjC{?A+T7atw2oZ|jI zEr&gZ-w8R;UXGhcUFNmD%7kEhxlxu6TCzB=W6Xi};KIi6o;ltz7xxXZEZi@)&*`z< zupJh~#9&iboCaY+GzITM8fL#Z>PLaQJ&jv#3jP4N<%&cp)Nz=3(l$&P}X&X%*oCO2M}08L&gj{BGM1;& z*2neV;AfS~cOX~WaOL8k7;IYGDA$&hTn@%8CLQOgSS~5MK8Gi){>u4&jPtw7eh*|H zwocU``v)6kf3IDpeX$%Pty8xgu1vj?f;~4hroSkqySiPb&&2Zlu6kK@IKANf#F`H^ z$~D2(i&Z{Zdg1yI%Dc~=TiQ1MEXW`**1bQcZn2#gYbOQU|3u2sr`voVZP|epSnt3% zs%-7CJ%hX632WG61FYi2du&@dj^-E)du-33zTJZKNtf7Tn<>^WhwuJw$WRJLHSU7} z-!pq=*pGV|zV;Hg`>0G@d(TYZ?z*dxrqPY_VqBhFyN}>u48OvL?~CCpZTQPEoa-kM zpI2k}MSz?3)?vPt0^H<$S~FFUuxw0{s`5PR7_o)?4@F zVAG#9*4qnFZ_V7q>>Y+ki}la0qb|>Gq+rizm~YkPGS6uM&xUQ~c@Drr$uIBJ{13o>0-SxIF}`-7k@*Wz2jjD7@wklp4TeXS&dQJ_ zZ;wUl%9|8y+SI74lCBrr8*nCO-|3T1*Y3MJk*+vgoy6I%J-0QcUC?RcR8j68%W!E= z)oIH%n%5q@Q-ZcnH>SP!9lAZhR~~kEkoH09;6_KTmmls8-Qnaq^qkVkuyWN-k?%mt zdMMHW(-N=RW z3JJOVw=P%vk;vsu3EIBUDA&-%x;^5ILPD<1Z(Xiajzq57lwkXvjdK0S$b~Zp3Awhs zb-8}se*|^{=UUr>M!EjZ$OXUtgj`$mrSI(bAkQfDyAjT~4)`mu zKQec59G=HNrFk@`c|>QA4n^r?i~$}7AI?SIJPvp7XGf7y9u)ZX$ zi?Ht}VLgOBpM;gh0On0e=(&Tii;}P|!j>mt8wp#Hg!K@%G6~yF*y<##PS}-6n1geR z&ecg+iLi1K)rTRU6Sgf0s}pul66WBnq;p>qRwAsDgmn=1U=r3v*o(=! zv5~Ma3F{$jUlQiv?4$E?5>~=J@y@GBSO;PIlQ72x?DZt9MA*S3tb?#OlCUnqL^2;6 z32REidI%engzYA5ToP6%tT_pDN`OsF!b*fqO2Rq_o05ce5#}ag8ws11g!K?MGYNBW zp5B?0gp~-JmxOf?Ha`jLB5Yw2wvn*KNm$1;z;+~IU4%WHgl#0OHwo(@?2#mFH(`$^ zVRgbDOTwJ#fYp+)5@Am!VI71$m4tN>_DmACk+8lbtcS4gCtf=DZEC zFbOLWwl4|mAnfHNtc$Q$ldz41?N7pb2zxyV+fCTPB&<%@8%dZm12Az~!e*BUYf8d8 z2pf}xIWqwpmxPrFYfi#C2%DIMbrCix3EN26lq9T&FgFR?P1v*~tWMa>B+NM-usKOs ziLiM|SO;PAldvwr7A9dE30s_m^$_MIVY>;tC<&_*wmb=QW&yS$3EN26$|S6Zu+>S} zZo;li!s>)worF2F0V^kACBm*t!a4|Bn}l@{c4HE@k+5~A-RcVXV`6N_wJQhXs#3TN z_h|T4@#3a_S5#i}=+B5dS6zn9-mP4p^RYgAB)GV@e-_uk3R7@5tL9zCnK zEa&C(7ZFGB&IGO(;=A=lXZ_dyduTP*V7F1ecq|!>XVv(RcU-)9#o+Q~SbO^mvF(jJ zQ+FxdCZ4Sq$LtjQk;k!EL;DQE;}ALsxh~I;drJ)A$K{Vk2pM=TbYQ9oye99V&N1-g zYZ4Ew8H0OoaW8DG$a93shp*DL18*|TXn`N-uJBqByo@pM-XY8(CS$J~@3fUaaQmwA zq8%S;0nVFamjch*#k+9B;=-1pR)y0AoG#!jP2tpmW8So>VJ%kRo!4*hP6*uL$+vS# z_-(|RJp8o=@5Q|nTo;agIHNg|Jl8D5sNh$iRXA!~j=VezU0^&f4%dP5bZ}3Q_EnYe`X!$HFX340BYuT)UWWD6nc`g`V2o2bGWYu`ndDn< zI0IbA8nT18vrs4d|MFiT%Um(|>$zBWMZI9zUkCa27ANc+!2fjJ39&xQGLz|pM!m;o z(oyT^b~?Z2damaC&SChneJEbv*6;Ns*L;~Tab-sp`CZ?G{TKNk^}%udRqsTd;Qc3^ zX#15feQA~NsQZ|4SIMrSx%zHrO)u=bo$*fQ&}?s4;%;ZWak=NB!`$r*y2Rbip!phT zutqQM6mTlYGtNUBd&74#8}4_8JP!Ocj|gwa5#TXBb6<F%VA#MSwbZ>{Fw-fwVq zJ{;yN2X`BAV;i60AB{FGZc%$F74$uFFK&bS@9O`px5)bXM~rLTplqwWhn%)q`mC#X zV}ntz{)l-&yO4fHVy)umV@-zm@|_>13wWJnkG|^e@5-|gvl!2IEdA|?vrf^L)3ksa z+K;7ZWgc#{(u6Egnt&U+8x0-e6KURLrD@XwZfLJh(JI^aq_z`U&-CvHJ$-)a4~XE$ zxD!s6G5#}jYV!jb-#0%n^?E&U>bxI;@e9XS>u4|Xd+~T}KTR5Oy_7td254T{m+XrU zeY_D*ELXUwyRYn~oz^lsu)QyUz5tu0@?+MSwB5t`7kSSa^To13nkeI_Z`cD{D(k!~ zL$rOIeP{dV(Pf7^9l;#Jz@t=v-JUmI_A~N({`l(ANMF?h;H6aNE8#>3x1 z{)e9AfA~De|In5E51$G7-_!qH{ePwY5B~=lzg+*HqyMkQf9ij+{(mL@BVF0IUOj$S z(mpimhWDQhpgm$=dXRLz&cYn{{|G^u_WM^A!)F?a;r$7m0iM zG7e=+{;uZncG8k&nu3?9JEXM+@ML*4wg>Q0V>9GwKGGKYT)VvIExbaut9G=N9+saK z*BYKQNS%s{Qg`0qKjALci|uwK?;jnFHiS2~2sigjMq@pUm-!}_jKlcE9uM=rJNZ^p zmLGuj?T4@bpp=t3(PKFWei#F=Cw1Bp;4S9e!`R=hV}G0fah{p=NbcvGa*?`2+yUAm z@FCvBU!qJ98XT#2{Fmb{wl93YK>LQUhLHX}cDgu2mq>Rd{>OGk*|bOxsd00~w1at< z%6^x&I@IIdC~iLD0ApNIe{p%+cet5+uzkof1aJDvKz}#v*69iGq;Cmf73vgaN*rmA z_>DN)qUc-_U>|+8(S9B_UkiuH*W%wTUmNK^2YCc|H{=UEO}@%H|1w{+qb6Ulp?1Dr zLcSRHhrby5q77f2kzX^1<9W$C&nsHzd1U)%e%n!ov<1xH1)^Hti~H4oEzl1-JJCMm zyEETEgf!bxS1*8HhNh9rnN>A!Cf~mA*n~Y#8ov3~KY)dMQ zD%z$TS0K;Qw&m$l(vZ)H=D2Y?w{5hr>^H|8b{y@u!@ddmnDdIN-{K;rb2(-KT1$d^5&w9 z*ry1DX_;kOS2pIQK3er9_0h29E7TY}O`E{M*irT`7wS5!b&|lr_%RPB3r^WuufB8_ z&%LD6hQ8$*&(LU`O~KeRi=JuQaO#0$2k?^RMgFqP(NEiWCfmkv1VBH!0CS*ms&!Cg=RC`VEGHIm7<@TF`%-d!E%=(1B+0qr)$bUe%1;bcs(0TEs zL8f8Wk?eTVB-*D%D;~L6)%{eNi02iY{Y~Y9+Z*hhz}(&D$^WKaMQz&b0bt%FeQ&uR z5IXD6Kw8>|w%hSr10Q;HF$ety@9x2f2;X+-GFyBNx0_*x0~;>8{B5TeHZC#oQfNK!hF}<;A7@Hbc37CwTfBhlIORgAViUO%3Q{ zrT9+`E->Hz)L^0cu1pQiHQ%+V!P(|JoEq@FholwL0-pC!{HO6vcJ=K|3piI-{HFyx z?;*eOmIB(m`mRh1PBY)NX#xH3B~Cakp#QA=7SjWCxa!-T9?;KO!oBGM?+=pS<>>+E zgYw&-9?A z$z;2HS-rF5a(-jCuck|6`;s;fHci&!+MK}Qoj&+4ToFi^I77nB95qVIw!4tcwQNqb z&tk2U$-D5a^!X+M^XruH)&uN>hcyE3bzuHM`+9(5R2d(h5!7@$?0ZVxCqD(c;ys-O z?31vM`HWp38s0JC9Ex%Kz$dylUeBX^rtu!czen|ZE^Q0GAH#Y(*Bw=QXGUw+ zk03q9ANsi3Lt!3iTWHU08^du2>_arxA|Fw~TLQo}WkMRGyT}e<{m}Hc+uH5*>ExLC zR^(6F(8e*f@t31ro(()xXQDJLowu$#x@y+}$NN%$$49^Nn)6uGV2FN!^G)XQOG}X+ zY~yZ@6D)el>VQY4EEb+vcX722exCs!_OWsvYsWu!(V)9Q+{-Zw-)k~5+i3~lP=8TA z%o?&@D`eSG&qa5B&^Zd_!n#z0&Z&EUUN8~*lw+u7f%@zBH{n0?Buu?>&x*?Ve3UcG zk8O}NGM`vKp)QPUd2+x;tFao^CT~U>1xM9M@)2LK4bBuzvV=hx$LJK>sTbKUT2hg_s$JA9i5W3e0J~; zhA->~_1>1&yErG(`-@mJrQVN9>D{Dv#JWdX-AK2f@6#py4yJp!{Mfp$of{P3PnN7l zc+17g&$pJ0kf*yK*ptEYLl)21@NLU!?1i33$@=jj-v6d;vV*-d|G@os(f+sA#DTS# z8z5Xi6QQ)%l?4rB5dnV}jBO^m2yy4iL=PeSh$og2@~%=J;dF!*gi{gL5S9>z2wM>f z_@l_XN)b-Re-Gg)gu{pAWa8ofi3phwDJNuXec3s%7IWNIUmVzjHa8aW9ku)KVta4h zKl;GSF5>o&UcUpOl)HCPqujoDwsoy@U`s1-*E;K$BLr@53GXqvsrQ@eL-+T$3g?xX zEn;<7O?_{|-LAht-4d?9ilK+_6@)(I{u$x$Px&dr3jY5Dp^N`}5!Ud(j?lyZmk@^d z|6_z@{C@$VkMKu~hi}^t5ekI=%6Np&A#@Qwi_k~-J%kmc`(4H(e46nH|C#Y6f7N#w zkMP?FJ%mpnEF*;No#+GaafBhlT?lIkzlBgBzKYOA_>TxZ_`3Z)!ZO0YL+B&?TZ9#a zUq@I&_%(zf!mlC}@I8A7p^NY<2t9;dp-i^>l7$B@5l;dB7pU3|Y;T;GC{KGzr&_(zegdW0ABP^pH-GRQGl>_S*Zcnv}y;U6NbAiN4;4dHtch6vw-P#o>Ax*Va4 z@ZAVKgzrLFMtB)QAK|44D+n(^SVMR*!VuvygyI-~)!Pxe2roqFA?!d{M%a$fN4NxG z1>pql6gor};#cn(4j;aU8Dl)q{&|06sDVHx3Ugg(O45mpe+Kv+XK z9bt%YDnbDtr4m9HVJrUwej39jw10$^QE2}R5q~nmGSWMd{}E0==p#IyaKs;nFa+Ir zgaWp3EaO3cG{PFf(Tqnp3ZV->-6BHT5%df3`oV3j(R&63Px> zd(v^oD*u1lTZ2!3u19ZBW8agK zziRAN+_?jMQI_lL9IqHWqz}AD$zPVk50_E4<3pqs;+u2g&%%ZdJ*V!-4PO8Z_d+>* zx1IT+94|wT=aBCHPsDPVxRi{xJe##VCG=ZE-%I5!#j}VpT=>2GysfwMX7H@Mv95*R z(|JQ${5E+r^P2EE9gn=4yom>wErR}LF%Esp4Py@ut&Z@ai{fH20r7p(pOIxTc~d{u z3tsa$H`D%%^*Qx!N54NGcIiA0Ya>#mT z$G@uMfn(ywF@HABy48t#%6dHTKub{nyOto$uW3gTcNB10|Bk}?T^(}r8};iF){FYx zEwa82KqvL$QSet8wbN(2cnR$Sc;VBdtK5H&bn`TJ0 zAgv8zvVi|)_yTyofI5bHRe$NiLDum);vdCcKtk_1X&Aj9sVu+1{P;+4nfDO#+A?%P zUU9)NWef#<@!NC>o8=;*|OO7J4oC9 zZ+N??Cx11hZ0T-{Yi%57aVj0iBlBzVWu9yr!?(;eeu24bh&PMj1Il;OZM>#w$-ZV3 z%Xn|9j4N>&N3?t!W`-D)bF3NO;CpAmKLjDmm2iGjXT00l*tYm=e};MP{#9lHz^UF?(KUm@)@@$9$UvEPce@=6hJ(g~DR z?0>BGQHFS)+LEbh1@vP57c1XASiep6vu#bLKWy6hh0~?K#{vH|vHBNd#I_->FCeWZ z>LpEoZ6p0BHNBIr18l?K!*c%t@;wON{O^!2=kN%bpV}~VcKWj2fR6n3P>+^uGES$} z0M|4Pwj!;c70?fC1;-(A|J=0m50JkQ?Tl+^HQ0{=-h||OKF?o%4E4XEy=<5e=H?-^ORH(9t?J25h}W#Qgp;f68p$yvA$TDa~x5#MoHxH~LdKgM;ka38jC z@lLCe_cw25=(pFx_2x&ouVmpqGGS2f#T{_7+J){nV*6z7cUL~`te>JbKiK(S8FH+} zo~YGk#M&#Qz4KFjL;-N};k{jaJNzqIyw)XoMKr#m`O7Stn{sGEMf3SAnp<*cyaiG= zKZ|BVlBT%sibTGfIIh!rD6Bgt=)~TE`R|m^2}<&R(@xrLv=xl)tiJH6IlNZ}I$jXG zD=Y2I$+X30rQ;BHHrad%fGZuJC-d>nEMD7^ydoM;(R5_d+>@jk^?I^jI?Bp>Q+a-{ z*~)uy<^14U>wf`tmAa8~`b_hvofYT=edK!f(RO}1(APOru$OD;s?|;YFK!#A9DJ3Q zp?B8JPm}}G+|9nx;$LE#;tX9L=LNqQ%&7BQPK?T0`fhHyT-JGSdXiTGa8(`)WqJHO zi`P9#UJ;F_XnveUQ^}$66-{3j&3!pEI-Mu7X!6pjsdWA!i{`Yhj-e(}qrYxFAa%gaG6lwl6i{{ZB znwp|nn?>_j4vl+(Oy{aBnpzG`MbW%7i{{B38nIZW(~(8t<|}>f6vZCp_a@;QQ7#I4&z)k<}2>>V86{=M`)iXH1~(XAW?zvT$}FU8KYDy$v_{4pVZ9IZ7X;6ukIMQhvLR z$UXr2!1#WZ%7^Obse8WZboIfg4~b-TX39P_`Y&ecK3$EQB6tCCS%!G~i1y~aS-j>X zc||leMYAG{W?l}B+b+{-&!U;1L*px&v$JRx=Fs3R7UpMq7R};Dni|KB*oP#|q%0cm zB-z&rUj!m6etD9oSe_WC#`*?arWLBR4*fQx>{cdu6%38%Ncr|>(X7s)!5a_E)7~ta zE0Z+E)mIE-r_N5I9iwnnzUEprlWOTwN>wzt;4#?8qo@Zt&M?Y$)~LG;gjMJIen>%yaeFQT{J9&rRl0%++}uy|V_n^|(4JOXty~ zEM{Lqq-4<-(SS9ljBzKtk`yLOJ|j3Nx504g(w7zvg+B@Cnf5YxLUOh zy@nF$vjDhk8+a##b#_4(ud;53l|s;x6<f zx-+Wxq7SpnL9Ycz?SplWYr(Q?YRrGMw!n4v2oG){iTn=BCme=P(+K#uN9D^iZUlVF z!|-Vy0iVh+eD+~&%+lAe`l$`W=j9Rb5u@|<^ZE$*xWn*ybp(98VfgGH0Uv)DJ_jYA zZZqfCdXD~^`ds0>KWyL=;W=-NfDi6?Otp)c&toItgL@xy`P4?hr!owmCr7|19EQ(R zBjDp6ou98~M!=^$44=Lc@Tm;L=ldhz6Ar`Y`4RAO;X{(Nt8x8#aRhwI!|(}5z^5_{ zpVcGa6Ar`Y$`SB!$L8zj>JjkqhvBng1bk}4@L4$mKHj+ee61Y;AH0j4TYuJ#fKP20 zJ~xhlj~JgXPk97&2m5#8^r?vwkvVix=xOIbYCaufuQC1jdM%2W<=kFWrJKxaw-!BU5x)+#K*n@`ke;s zqth2%T&eFZyA1a+neR(*hO=n#86)SP5nnUE58?k1;%+L;4G)xgCx}h60W^qnIghm7 zcy+PHseJ(=exq)=T;4asJFfO&f15sXQWxU5K=$MAaRL1jI49*i)Z_XC_S2beh&ky1 zz9pUqJdEG(JV*I`$UT4fD_qF`UKwXq*R%{FZ$p>hP9WqrA@5C)7imyl>Y;^qxm^al z$xB=44}i3!ek7dqgk!&x@K))+{%v`e&d_bmkq;#E4t<z2N4;=!o7*pxTT?8C!M*17GdUfLe(Q0iZia$pA z5=8%5e$Gww5r}!P9@3vngttonK;gpg;|ZKKfozW0h@px>j| z`7G9)IA#~e%Qi1+#|Pt6_OBJZZ9dMF%i*VkI*hYvY`4%U=d7_T*D1fW^quoIPGNbY zZF3;MN4sV7LR$8Jfjlrx8`hdiFJTLyd)bC8o=w}5?N<79TJfUqeO3BI6@7n|zW)RJ z{o0okaN0@Up`>iz3AB;b1K&g)llCaKACW&EZN9m0#7<|XTC?d=<=g*J))_0lFb8WB zuz|SePM(M6`6lQZvJ_`YJ;8sBeqpr7hQ}JVP1Iq+9lY7Z`&;BU-%kQB@W6hGqC-1H zUjZMqc2PZ_Y0Lc_*g63}Y~06!|5azon0HG!U~E%_b;1YLZSGzrntMOuZK&KU-Y7pO zHjI8Z&$Nrh&F?M=i6{Nk$m@vcuAcO67j$*VP#PnGlB9F^AL%)hOGwW_dL0{j?kyp` z64ER2PE+B`Vt?oGuAg?@-jE-{1pT7fS2ADxX1<{V_?j7ANPpTo=-T0LO8@1A{^!fJ zp{QQVHVM5--K+E6QJgamxQLT=6MkR~{l2b;sN?-?r&q)NM)m{m<+A^LT-)Rx)CXC& z{1Z?XI4c1-|Ko|epn3rI(eg{|L0jfK&OY#J`aZDThCT$nR2-M?F>% zkV%hK`kZiLP}4eTf(&|(wa+P^7{TAHD%n1uWjhhF)vWUo^y_ji8jtgr@m&aYDNI#;% zTaTn^&!Ta2Xz(s0Y0l1~nU+H%PL?#&vuI}K(0GbwQWnje9GZ%v8Jk5jFNX&2n=wCc z?$6NM{2Us*twovxSu_iCXnaMpFNAd6;Q4oz9n zoS8*)Qw~i<(Uh`iZponu70tvfnhiNL?rAbVqqAuI92&g8M7{mjuQKex<{X-`qWMJ@ z&6XURilPa#Xtw6igo@_5ESl~d8n;E}=YMC>Y|Ei3E1GH+%{@6ZxTlzUdpL{cz8soR z(cGU!Q^}!mTV*2X zG|gEw&*aefil&%F)0ab2Q#8N9U8N1rfB{) zi)Nvu=`;Hqdal{)h*?s$2Vo%X4VN zY?+^RSu`thXv&J_+ANxtIW!eTb43=->KvL-(OjHGb7c;VJ4fbcaTd+hIW+K(XJ0Zm zi>91IQ&Ti;Sv1$>(BR%QrgLHz&8s;yo}w9(MYBJL##c1|jr*syJ&5b*>p3(vMf1xn znu9qsf@g~hJL~_Ky*G}tv#9Qe=ec*6EF{X3ED#`M?13uf&}(%0)i3?Zc<1q zmAgPCnphJ}OK9@KU4jxN)?7&o7GAw8v_haYDz&)^?Oj2QmDU)j(u(!DyPE_Re}Z6T zE8+gW-!n7MGxOZ%?ruPBKcDyg<9_b*oM+CNGiT16IWu!+CJpDsCOCPG^LQGLLL8>E zuPJJCvWGdd>l;WQ0q0kin&-9-i5i;F9VdJ5cCFIGORQA}Z8Fyxx2F{{ zCmOx0BG-v@T(?Un*c0a!?3h>Tx(WLUBVC_YQg~mC_4DuGhxy(OeJB&>h?ig<_9Dy! zy09|<`%9#2Xxpn^HM%(szB<9afBWbQ3D{9=|(1?f#_( zT&z*fN#bJflZU&_?4M2M3;6L#+-(VacA<$|PvQc8R1z0^fV_Oo-h&370ske==XTR} zV&8)MZuhx2;I6rJ^r(tIKeNgTE&)56yOJSXdb>Bb- z@NXpPbaeRq?|8S^rdq<@tDPENNXirGkDc$!glUffOs`w(`{8XoLO2O)Z*#c*w&fG# zF?nWr!+D=My{`uAR{FfpMfyEw-aFg!hhO@B-}SNvjkKq#t0cY$=YOFbSIzvV$v4dW z;VC!F43`&XzUFn{32{R_8=Pkv(Dr-h;UFFcHi2iSR8GQo@|u}}xS7r(;uL~ij6>l$ ziahHpZ_iT6>R5^%$Ys3ra()liR29$fK^`It@X0kt*vhrH;LI=Zv_E<74(|?p4tHI0 zt&;a&as5%{^Ve~YXBqVrz30@1fP7#b5&I|QUK4rdJylq{mb1qAjqhh8f13{9_&k8K zC&G(W#nWflhXAof9xTycw=4m@VZ^QFu@;X1V3Gb;*q1j9pC!8MB-=7ieaqaVh;;eH z9i0AMhkNcloaH(1@p%Y#Z)W+8zOA==Gi!?wiw3zO?qIZjw(@x9zEzi2Lw}asw>m$8 z|KJhgV=djyPizr#1idIdNG z_a~o69isd;@1VLodR8VK&jVtN0OA@(@1Ki%BHynnZP*ZEaTsfu-Q$;6_A<@qT6BIi ze1Fk9r;4;{_-12TZG50AKu6){3{Xe8_Kp}4wt4EPn^$mm9IH2sc2{4kD65Wet{saL1>9%GxQcefJ$}FIdiO5dI_|QK;w2Fi$-5NmS0T2N={qKv z{tBcgKk(y+kY^1%{5Q|^W~@bu4k2zvVlaXo_zpZd3k~)t*ok(G`am6a)KK4IgK@r} z*kIUV@!!ryKD5bg)$8!ibI`=TvF>W{X~)Hz;^4t%60eK#faB%Y?%*Llka&G)ljGvy z48DlZ4vi=61LdWj1xtcTQXe4`(Mjg({6X&+w$bAL4oF znmo?-GxrE1{YP--v#Xn~-g@vm(H0>?`h?;8O`CW>^a%B)(7)CIBOmwuXPs?0(rwvK zk2HdZI_YHJ4!*oJJfjQWn5Ob5xz6Mjnj8Y`^Nas9#gJWC{y@O!z1X`@NC=d zMTa4$?)>Pnu!nNis>7=@295YniI+v3n)HQnnz%2FVTrzw_y2{sZ_M6t2V1p6sWVDE z>zusXI(ZH6Eks-&e}^~kHL=Ew3l8o*yd3?f>FZtj+5Rtgyf0VV|Mhi14=$#Upxe_H zwz&(?rj`eC#ys_=FN^cV_@I}sHY7@+^6B@WBSUdjHa)Q-c_=%TrT}h^gY$? zQD=9;9jVY+17an!N&o_caGq$TYWwyV#uT( zbZoa<|6&_VJN4kS4WP~T>%s2<9JC0hU#)ezCyEuXX9G{KU0kcvg~`4STAd!?{%=Qa z3hyrd5$h`A4_*9mb+r@nw7QBu+Ql8Sj!rRkgny|cl%WN6PuqGF>k9v^tSkK6x;h|r zb=16r$giQUgpZWEa_qIso7iLEh&@K$ozO3@ZnA;I@!N43>kQ8V^X^YH_X4`KqdLQR z#2(z7kurdD6kPakyN)PRv{~&Znpn*;+b`glTdZ)r6fmwAF}sq^eq&pbI9}iG2NRI7 z*7-+_9arDs9uUTd^FCF3#$K{N>@5GmLw3&z$AaXgAw(buj) zFNe@y45O|_kZ=9t7z5pc-_7`K^~+-Gu9#>?w!IDFoS9ctcY5p*+3(c$1-*>=f^MgM z!Jdl^WgVdm^2|CxSHv+AkMdhZg`VJwsUrZB%?`}vUmUjkQQJ|g;l zS<3f<^L-`0e;l&Kcm=$yod^H3hUXA4(732}v;G%d5jfJ{g75G-qxAGY0h9DwO?uQ7 z(@=+nKInAeUOJA8!prg;+e{|@Pho?+{O}EQCNn?D2lNDwv{okY+;(V1dX z8=EWX@l4qX+}K-zZmy{WSKG?PP}?b6XphgTL#+P5;w3&4-)*C&D-WZ1mpX&n^^QkG>ll7QKs4 z3jQM-wh;PheFQyk6s0xuDA9X_i}9QIvo0>$DCg-|%#t^Saz~Q`2@i(h;lQW!*=| zaHHQf-A708Bi3)&@;b&sZn;u*oVsYoY_QXjj-!202GaIfr+7vm3;Pe9LAuvd2hCWE zY09vr&q3$VZ|SiX(o-H6BHeIy+O8qMlXdFyCVen)D02_ax&)!=&;x$iI+ z-*=TmeJIos_oBJ@PCp&VGC2pNNLF2I%%MrC-dfiExz*|`q!)H(XFnTv*e9E_3}4oJQfoAq~_|g4hOV{XPplFSX#f5bc>?I+Jg z|J5v$M&F@8A7ADX-84V9Y4{EOnT)#=bbf?1F3&+3`h~RAFUl46!`Gj^dQQK9z49(z zc8kpEM{=XhcfV7|YVjTL*mr5>LKeb~nsWc=!#*!ZZS-k!{okb-fF|XHyJ0Gr&k)&V zC^O2Aa^W|W9b?R0BaoS1muW-ZI#z(?qfabtryRGPcigYrPV)SJJHBywi0qag%SYw6 z`czBUvx(}Hl?ls+I#?UR4-r0brnEA9?oI=r?@rWDa69VH$V6-e#z>q?u<{W9(|ivh zGgn{UO?_cn>I>3{-Ze@4PMel7Y5j0zExL*C zEZ5vbxs}n&vW_o_>fxwOzgZpPp2wvA4Bp4PG3~kW@g3YzS>QXsZp-{yz}S_o>huSI z1AD!nccj>K!CZeYszRS4dEs2Ws?mYJF?jT8XqVi*on0n<7H6qvez({wxYge&@n03+ zRI>HW{_aTm-S#s1{j-Vin>(|VxulWbHyfSfIzSq~b?Ca49oO^N*D0)1g!5H}Z5`vK z>tx?Q{HYyK!9S9*S`-)cDo6gL5j-QYBauFlCiRc?SB2k4x-lQBKM_qYrnd72gZhL!cA(anyQqV$~+3NJ1pZg>Q}e%F@eWt&Of{kccr*I zj3uuE=7zPr^qi56d#GQb&T?rmmZElrD$N4#zvzNZLO)L3#<>&v&IbMb`5xr`5WXw6 zr*^fW2fY5YUO%x@))(yEqF=Ua>Tw-H&b6zscHdUq|M#SCeY+O*`9aXUCqeVsh^D@q z_weS=N8`0J);cy(_CfHJ9#%jCQg z&L<3^eQP_|D)(NIUM|wNZyTRFwk`FAnD@e5nE2kHKxK>KZZ5Z(}%BfK@sTi=si zVLS-*pkmu_k#*WB@25))j(nRb?K}R~>3lmi@olE_?c~I_Q=M;}iElHUZ!;3#PSM}M zS5$w?rT&C>)(tLhV*FF3^Tq6j_u(0JJ(X)v12_{v&dWI#b}Qu`JhZm!;(7hg>9%Ud zoI~)@hhdjT&{rHldpStkg0(^D{>7cDcur>ver@^4*aI$Hv_*Mesl1fi{FCc zIXT=l8Db7i#@o;v#;z#BwgQIn3fK7{_fc7ogijq_gm>r|*V5R=fGh14_k@p@o%0V` zI}j7=yz@>G_g&_0z%$R8%4W;FTg=!BbAO1~zwb2I2zzddM=Q4q?M|Nw;lf+?;M@d< z2hT={?SPGnd^K&OST_2X>V)Dax|I5;e%EDGbM;s?;F-F#b(n)@9p`w)JKxvf9p@6| z**5sTPQO>#2G}k^H&9!?;L;3$Bk$88Z{P&Lk@p$;U9C^h+?YmlvriK^LL+Br0!QBG z7@C_54X$mH&n+eoyVfauUgy&Uj?h>F8k7-ikNhvvGy~9(_oe3hQuDsp#0%K+w>aeo ztac*i63HiN<_r#H!EZRLCLquJ#`SsrLoRNeW|#VU7Wv`O<+yIOAMWCb?FT*agGAS? zuluE_UliGxIxoH&=ZQGFWaGj@`05_~c0G5WOTYubEj_iQr;_1Vo3aOezGoBfEs1xI z&2i4xevSi)_bc2B<>k9Y=Nm%zJort9p9DNW`eZuN$2nsATkzu?1$`Ih6(X+_V6)g) z&@Q-mEepnIWAG#B2W0YgO~SM>(1hQLxwlr)c{SyHX-ECXD)vYFX6Jq((9&OxukUWu}JcqYbACF)F>x@3EH(`O4l zKUU`&_yNAow^9GpZ=k+lL#4hpqQ2;_aShSs`{mYEXQG~ZUamY?KQi~D<)MAte{Qhx z;s;{9gZasdy87gmHPIL9O#Up)Yfl!R4luE&y!(*4fOx=gKGJi3nz-gW(wwDQ*xzS1 z6d7BDG@aAo^TQ?=F^0_M+e?`@$vACafcvWe+oy1c(!QDSsgX8lQSV?nRcuFWNia`s z>f2KTUpcHTS${EFcSk=g`iuTq+70?>xhE9;rtmRCO=ExYUibld)D?X{rmvxY1-)A& z{*q}~Cg5@oi+IGTfp?De*cTT*3*P7_v;XDX2+GRz9QRoqnR|hKd+p!oy)d+$ToaJ= zP4ei%xPdg|IU{|CsvWx^P7~$c)>|;=N`>0D86~{v!25YdALWm@9`OEbKB+IOo3|f} zr{E{Lx`MvgYqOb4e7hgbX~HJxF^8Vh%t z{PIOHK;TX40snQxjNt6X{Rhz=?AeW5albiiF3u>_c1q`mcpT%G+cW&!yfUkNImp~N z=;k@Tmwrvh@w+-&U#YIE->1%k?)7r4UEu$jXfv?aqJ#Ibopqkh^V>qCbMtGt9rxEb z{UCiR_g(xt@H-ncai*8dwho|f|4G5y#)>`Cy@ ziTsO6*wU4UEf1XMnVDaCco6#~LjI8VFAOiQPUPJ%zQb5DnseKd(RTUJDuJNy`j9DR{#*gp8dwrqNhXtCB>7OEgR8jlPqE`!h=mQ*A z1I_@-z%hFlWIqdO=#$GG&Dl(8)|%W4qGO9R%_{mpkDqOtrb@!MYj_^MXV@$+;5Ovd zEG_6Yq(%ARJM;!^&`aP^c1ruYQJIa89lcAR1-ynjfn0}B-b0|{`q*31=ji@Y>xx(Q z%Q5!Byn+W?4;bbaTv$s!T`%;UVo+L+G9>$y@16o3<5=lTpVoxSvkv9CD=3XOW^nmb z8+Dx(l6ARB!;#jnd%)4pdS#t3f5>ZSYa@SS%6pEP54ja~oNbUmm;@uTr9`Z7hv50Oq}m-zJ~;~usxwA&%zXj{=D@!_t#WUP(v9BaF9 zW#?@^4n9Ag;Ika_In(fogHrXGpwmtJN8ds`*m&4}%q!qo_{V<@b}!((0%5Qh^3Qn% zeuF&>IIqBOoLAsK=Udo^IQ>eP(y!zRLwd-0gc zRlm2W(FKrsF@yag`8Ssq&VbFo8EJ0Tb(JGMJfoaKuT1|5bPzWtv}EkV{M+I*Ri(Om+pky?t^H% zR~=#7HG9bmloQ(4S;xSiG%^%^0sBw*8vGU%I^=v_wY~#)+hJY^u%lmPzU9rgOX6=I z#kU;VzMKc2Z8b6De=qZ0&#esZ{lz;o_x_UOPRujc^?Yumld1)KfH)V7SgCNiIe-2( z=sEeAp7-RVp4aOOHI%`Xn_34y26W|&UB@5bo_xYd3w`@2{fR!{D#)Ju8zm2n2R&LN zI*&ojS-S85aL$EOhdlUG2A$OLt-Y-DCtyH7ugMR(f zs>1eHI~zQ%gj^9Dn8O?c?AvJg>7wid9U2Zw`89*V_9vKo z;9LdAFE0FTiT-bzo~Mg+rUU*c%W*u)5%Gb!4a>_3;3a|^{!S!+m*qz{qF+A*zwaQP zWgZW9b2xh<%6kINP(B{ve8_lj_qpnfy7n=hc?CP!8^cvsvf*(^dR9!95J7273Uau zKg51J7wYn7`B(@(>UXFL<54U>;T?@SGLYbBtokOM6CgMKp9no?oz_pDSe;tFB+lUu zqm$sThG(mj-}-O8=l;2sJ+NELV7EAL^(`}(7_V(}92{P&Mme`J-gqo+eGK-lSLPG1 z#o6eXSEU~p;#o0fi1E67mUe2MVGEI7!&z?h9g+rTCnSATvql!R7p{?6dNuGXYh$Rp z^tCa)eqP_&7LU&{?^r)J@NEU{+b_Wb?e?$4ZsY73-@egaa}JVrz_Zyn%Zz95grMo$ z>=^F0Bc46uzH=^$bo0=8_FdjLbIwdZ`?+I##Gk?*?GF3=@y~GHq=$XMXnk@p`g7=} zi+@z!&r9y1oeVmRfxc@}sS9?^O`mD^({ueEZDRij_|kS1`|7}}jjQ9HT=qXF;r>vU z4&xr&cQaoQ)gkHH{S-sc9qF^p*cD~jP~aSNxAC7&^!u)sMUAu(SB*ZYMaPWR>-#e6 zyKy#@9t*pCv{ijvk^LDMJ0q{*t0t93w&I8J|40`982^vV#y`gYBP;QbxyVDXVP^fO zw?#eki7d*_yJOruf~V1k{!Hu10MysZz= ztZr=EMcJS21OGO?@WnL^wBs6h4C`8lw$@_5!o?i~Uy%KdAb)l#XJQ2ZU&^V(=on*_75W+X}w?CN%U^w66C$5x=8M;wsf+)7s-9q_B~TxWaoV) zeXwJZxldNdEZB6Mn`>PpV~;2w>gIXqi_xwS^TV~zVsDwg0Qx6c1HMq}To2^t(qTC; zt~t(y1v%W?4ZIBIv;=>j+4l^8@DFhgy1G$NbKaCbsn9}T>m}0z<*bZ)>U9nF<+^5!nT30H;q#7tHAzjD10daKM#G^eUSHk zx}D`2vx8^5_EW{43E>}eMIOEO_X+=l*q`FUGq?L~MEV}^Mfo%TJoT4+Vt%RfJj6-c z*c$qWp9LSE#kahk#|klyl6S0^(ne|?dk)tp1&8Ii16VmhWbbMQtw%_7q4Ic79e{whk9p-xp)|tIB?`U4;%iMZF z{9`}qqx`4hT!zi~R=>-)&n;VgTH+TVJ!2T%Jh=uigt-bc){WKyDC7Rm8W}^MRhxPT z<1E|mSF6z9?dW<2eaGs;o<618b9-|L!|VKRco*yo^5{Yx1XxS?J@VYStTGKgOZY+4 z{w~Q^e)tQ#zaQ`K??JoJ@(NG<^vSXwx)yNIQCpVLH+@ziE=cr-zCPeXoi|pN-JU6_ zO;^4EKj2&8=TO(w1AMQ2PTMxcz8%lRFQQ!#9&XNmp&NFujqLbGW zA;4=N?5Vs3^P#pZvq%?tb|KHqrmh#l$MpPu?Nh*g81)aI-<9W4I4{)lPgx8<*HRin zI-Faui*Y|!O)2(PX+!ELC+1KY&o)4w>Xd~#j&to@NZ0*o@GuVTA<)KplF%In{?M-w zhw9Qs>~)c4WIl*}9%Md96W#%t)%z(9 zZ3kq6@!=@(yC`?yQ=V%X(}41k7T>4ez@Ds=f=_5V?zXm*lu;|>MQpYwUJ#_;*w~X)C zChYcudOufJ!iULh^xFyeeOkaacm>&D^#2yFK!}*XO`7yD(^xFTb$mxb2oCl-*qOU_ve{AuX4tkPI*MqbVBHh()I`ostbd<{%knRuMbksGIZ_xh7 zGu4P%xC&|B;ilGX@b-HEOO-Q%E(t?guo`?LlHj&>}#1tC&{VDK%l{Iot%Fm>u{MI4evu-+9 zekL8|cO}wcE>71Y>7h*T*`ii8@NaM||CH&!TRil2;T?we^YDBdo>6|r4&|NLp*~YD zHQHo+XZ{_GVWO<=pl!QyW_VjqWhVZkSO>%y{x$Mq`Wn(;{X%HhkS>_hTKPVCU|y6D zXnoJ+=~joQk87UP-1957TYGfBZ}?FQ0QnGgF~ozD3L62k7TXdnSB?@MaBT-(N%Q zN15>-kVyeDVXV2}qdX!zlp!g*ORemXCXyY}QFhyntR&tS`Kk8vBU?b-4H)N3c!!4P z=m+9m`dP#X2koXVkhTkHgO1k9Fun_}i6K^iV;&oJJiF_$e}ruxs>GdFyuq~TkSKlMVer`kt@ChGt4vKLwFA#s^6Any%}GirvNa&NCrB z*{m}2&h(9$o<7YF6@JE7d6)Dnk$e=^^=tS>dG?!j@*?Wz>5TNNaXPH^+jIk$qYnXX z_Q`Kn)pO2nsh+d6t$NNmQ>y2j+g?4VyQ6x}$=Jhi3idF}z#fKEv4>%%*~9SW=}12V z>2pXw2kGY`{Q{)N-iA}Kw_yhMHk^vR4KvN&2Cr<4p~1YY3p4Yt5uax47ron9HkpS_ z*`x3UlvDILDaWdoV-LnAIL}Ahc+7<>`0U{~jGoeO({rLxenIYpIPHt8Z>1e|`3;uH zm^Mn^Ip+kgJZcH%JkW1F`VQ3JH`v~>Hv#>+OQR(x@p};s^(5+MIp-IHT{pt7BTwAd z{D}f`90&F}ZoF(8xoNEu*{x zz}<8K$|G}6qy=9y1bx!2{Zi}LUYxUQ%T;(A%7}bLpYiO`xe0z8zUAQGytP>!?bAFB z!hf&-%-4%Zju-fJ)f{~`by?f_s2q|Wvi=y`0A<9v{shgV^n7)M!#Nd?=O=twWRREp zJ&W&RXE!bzJ@7M(38bF%JWG4By-^Q%w{#EqK|90q%i9-(*ie@T1>H%uA@w-;TBt@9 z_Y7U7bYB1-xz@q6e0ip?OJm$Nhdk(;He35}X$3{`Ya^M`4`!V|%5?9ezqefE3qLO=MMuG_t1)Gg{2`_sI-we6#d zcAlfnK>fS2kahyS{1>zn5B@0f!P>P8`)%mSGOH)B#ctjTZH;|e&s?o1Ef^1pKCwS! z`^Nmi&~VnyNr=6C3+`+PzpqBa?`xZsryq0!Z2V){(s%v}b@e@bL!H8wRffKYb1hMS z_3s50`e)(y`o(tE0Ef?qxr+Sgx9=d1v4cn#0r8_@XamE9Ol8dk z-`F0!vKia(zOMgS+dw%r=m+)Sf52YsWgW0yIX4OYtWG!f!OT_W`A$DD;qP0YXC206 zvQ}-R9 zC;e&)e?8EfACJe|<&C^?Uf$}Rl*{)mStbHA{OhY6^yRg?g3{0_ zu(ihmXE~lH0V>()5KSjrGE3OY;qxZg7m`2Lv8_aAH4Td;;h`w_JV+LEQ!>!{mo59kZA<|pw4&N&-j zlrQE>_coS+d!Rz>rRBK<)Ny+rf$SGsu1bqBpDObNkef#j z^t;&)0_S*BzwUR&D-;uZfoh<~ysP#4Gnw^gN3jZ&MGa?XK(_lI!8+3SaUR9t&Hp0t zI`!pQ=tz8ic8I%?)H81?;XHJaEBs0?pSBf#zDFZwQu=55osfM7|8?jH<`a;=8ZBT? z-z0TziLrTnZq1)7{w1HY#dAxU{^EW<2i0?t-uPei#Xu{-ei;7S`TiW*tXt;ngFY`3 zyUX<8fqpF3L=ms1$5aK_b(|C8m8IoQJ?Gqtejyyri0tSG3O_22^`LI`U@Yh5-Tr$% zEwq_P4i}@{FyAYvqbiCMBoA!2hc{zi+48Kvh7LWhO+(v4d*dDvoWY>im$AOW`peUv zLFWVPqsgi5(LO-(^@HR5GiV-!zSJH=n;+J`{4jVKf?cQqAG$dDci5Xmngg)yY;U`% zqlR`qLHo6r`LzFf9NNQwsM8Okk0tF-I;n*&NqjwSf`)*xqlwZ)uv3!)(!iTl)CAH z3?jLM&c9)w4CM};6xsATvT@~}#QXg3YrHPhHDxM&pUKaaX%g@66Y_l%@)I2ZFQ2*9 zFB9VssT-URB#*RJ^nqCZ$JmGB-})UKWAOc<77d?D-vIAhV9SKYVogJVU&8+#@nmA} zNPmX@CVfA?-A@{XbFCKn(q!-y$3*^-ed&)kBbyaub zFp%%Fk}u#DmI43P=HyXUmsW5!Y=-$Rz9ODGX{QJ~PsbINO&$T>3AgEJmzY--^P?`! z?B#yh+&%4XI=vpNFjuShdAQ#)t9^UaY)`I-v(C@A84k3Cs=4<-=2%xtZucf)O$ATTjTTapIezh+-dgSU&5c^{6}qmqRpGT0?P>=+t&Ls zk~!vus5kam=&KN~yFZH8#q;od*m3+c|GIB-`DP5R`z|rppm#jzx$qMTE4}v<85at= zC%2oJTs)5zXYJCOaGqDE=XvV8_(-IH!AguR7L!wi;5NA55_i{!x%h(T@4M4XOQJNE@!{DMV*3JgX3x!vk$~M z&lkgHUxf8L&R2p~4bRL2?R@Q8#(G{{tOU5<>4UeSO`n4N;m?N98O)1S#D??SGACc0 z{a6W6h5)e}HKgmodV9dQzhpY_l9mp0Zk2OrM-%DMXJfn#J~z%>$u)eI5q-y5u!Wxp z9$f#JO>fJZNu)>luwESFs3$i))&;*}Ts*|zyLcF8z?R9@ANC7K{rm)H3L_R*(?ESNw$0YvMbFhe+rrp; zw+%?UMIXWakuF@VSvh(Lx^WQoY-8>pMmrW?%=nhnfyPhGC5JK(pfV@8XWFANCBS2V%Qv#se;mF~>a6hvb-t^&Hjv za>yvH-Y-bj`=drz<2X^b-mM=<-$;A{%;&iAqXVoj)awhF`;ypb)^VG*{R7ayA;<~q zkfLi(;htr;d@U`0eR(sy*q}I1!0*s`?z8La zCeP^I`o_8qTfH)E*s(jb&324)CGzsqn{)3lo~ohm90J}j^il3gxfyK_VQb!zT4JmfN&{V&#eK8ibAnMV!!R>0oYAm1IGjqsztsNZ(6w*OJyWi z4=-(=+`~uPD|QXvL;D?TzO;RkhBl6AOuLTKpns0iB-(hCrr@MO-3y(YH7^A{&WXw) zYZ&-O``0+nsLuvO{WQI^$E~+!clLN`n%>zH+aR$uHnv{Z>%Kq*QN4Z;^?FL8UbB0} zUPtA!_TTjD5u9@g=r7%|RrIY{`?7K6_8eM!R+Aco$G3sU3#p@!{~Js@$mwxPlwalv zpXag0W$%NY&o}hu72p=((0Cf3@A5rI6r@=hk_2flnX9g8|p< zWs3H9v5m64ug94rZrbtXs?Xk~TwOd{9)-0R4{pkn$K5?1+?1zy9NHWB_z$cX(l%6o zP34U|CNh~r8(76d-Eybqy&vHOh&*l#Zc9DAnpo;{qE%sopcE&HNbJX6J_VP5i$ z`-qTN4e9u;8}lhw(GD_Cegi)e$BOX+zb)roe&C6=jyA|Gi`W-@lerPlVw!3~KaJlX z>81F>$HHzUZ7$?G1RCNOfOqVt!@l6muJhpsw;(oRE9B++!X6)bUMb4M_MMG3&z{}v z+oKDNE^%(orF$f8c*~FCyC~9Zibq$^^F;hMvkfjzvv#KYd+QIy<#KUtTMHBAQ#(wb zo`5&l2&A+2K*x2*XIs7w?Im8j8i$Yjb$-=EKcxUq`UGr`=qu%{&UWO{W$fdVxKjpt zwxOJ`cbOL_W^Y}&w9FMhHL3^KPo-b747w*gnEj$I?!@ZD_@~zY!dcqGI9qW9zUl$^ zst4h#iq8e#y9R%P?X8RR(8jmOv5n(d{BpE2eg{9&9;aeHn`@JT@A~D~SBADNbTg2f z%QN?-x$m+s4RmGf1{|#WRig8&=&#amWgVEiGF;qdBnbo#K^?y?`+`RhBB^V z`*Y$llYCINMesLnTJ-x&+YjDyuq%ku(f3`GKKotdDSB_}Yc~62XMEu1EB!9MNxzG7 zT3vDH*Bkr}6TkZgl$o?hp1qeoVV-^>bP}?ufR7E956(NA zb<*8-4#D_Z(R;$zir|?&G6sm=72b!@W_(^ZPY3r{wbs*~PTr$5CFz6Qs?? z@S^GaafdhU&5v;wh?EC5JGE?R4=!EflX&!!J_%!8NV^5{{V3|3cfrWJ_BCT%`tT@k z(uaS|FKPQ@Su?(fbs*;eK{u^$ox|KZ);B!4F?ES31hI1;X-p?~?glzwRbl9@=}-5;oN9D2C(Y@$uWS$ zfd5c{TWyTW8S*2MGP$7|ac z=kfU1c|g{jmy@-JWFD~`tlf&`(AoZmnK*a+Ay*d0&PI6~I~%>H+1Wf~<=$cA(o=V$ z-I{*;t9E<<|Kd#SbrZd&uZeyUb7-)YSIrF9uKhxI&Qm|1sjm4{{gmrx)|X!?JSO_p zh#$9KtuM?!6fV!rjQyp!tgy!q)lbYnRDXDupU33uv2X0UnHXzVT)ro)|0v%O=8xH? z-E+_$Mp@mluitmXeINS{H($G#-^@)#LSA$;BCiPQhMo)|AZ>ewR!_Ss`jPU$! zJU5P`wQrcrtD3#yyN5S_LDoL*Iv_rV&ePsi1^T^jm6(u-7v2@+(SgphUD8Kz;hB-f zbhYJN8-=fn|3CYglON6xVcS*Pbe}m0yX(?o`NQ`s{IoqR)3za&D_oh4{Z@SYbH=XX zKfoTt@O$}6W=rQv*tp4ROE3+xld~S=JN6rfk2QV|DO=zLz{?pt*+Yo5F3j6ci2OL7 zarrf4tw?6pE@?gZSJNl|lgM2`SAIBBzwJ}eT7W&jJkpcH;Z>^iU8MPoD2?^?HH}kH zcbc}w)iJ0hzR-?k^}JTZlkp*=ckw;gSHN~1gx`2zC49)M;6r{8J|z4$#-<)R13&nY ziG6?Zc~ato>6i^WCN5J)FJrx8A1nHMwEM%>&daxz=9{+thjlr42E6taaSlWrE6Kk8 z6m=Nw=5YO#JkD;|G?V>DFt@dW_8q@3X!Y7v+to5}kXlwthxkLFhjv>zgjh7%Z|TR3 zZDo57P*=8po_KwuEZIiCmu;VIcO&kHhfFq9;ZtyZ&fQ^X1=IfrpeiPTM zKVLcEmUe{jbKqYwzS-ik?{sZS&Dar(S1|7@ftTc|if@FuG5`H0{VxycxuvNo zc+A7ipZ1Jr%ugSKuP&$j|32{gQ5Lxq ztFzejPArZ)IW|Vj{~K+dZ%fFmMfpC0%!?s!obfx=Ew_4ntv;_n)?8Y56={p%x7)UA z>7ULrp{@Qo;{?$+a!lmrKM&t)h&AD!YxVr~kMW+3;PS2edsO-7SR1;<=9yzm3)aYL zz|VgSx{0+++n3wCP6VwRA%|t*1*1utJ-}yrp@VbzI?MCVN~Rer-)Nk@T;EX^$@^Hy z`|KO{qdtC~Cy%(JSMu=gAT$00?54yBcVaFO>(m&tR50f+Yk_+oL;Il3gYAN>W$p&! zJleQtP5C4aK8L!G{gN@pVsrI=%L2~HvoaJvcZpxWwm*@v59}ZFt74qy;Vf-}b0)^C zTu(q7&IfT!a{=qgN!SVl%Q@-F*t^1XE^G?cm0Hsk$^M6J!_6aDgnhM0lOt_>kJ=3MsD1(FW>5#Neicmpxv&KW zR(0iV>d%EeZD3_5T`omO?l-WaldhPeBkNil^&x~zk~)HOOazv5=%wjM89Ksw>tb86 z7kff0jNMVw^fPT^p8Jde?_ioq`k8fJe3gEde*M+@nQ<7!qx3V!+N|dwY$+AYnS$G3 zgB5HM^Kk1UbD{X^ejOq{DOrbZT?OdhgnqF#iUnA2=yTkuZJr%}N4~5c9~&E41r3jn z?LHsTIvdi9oyGoP@}zx4+fT=|u_sRGbKhdlIj4kj7d-^r^IPceL;r5nW1pz}#y^PO zt-ba0b;g&V@rmu|-?Wb%CHGkdRL(5%9GD7KIwO3tXYNJq>gh(MRoj3lvB&W&MD|Ih=&jQ zCtwZc@Mb%fiDl)bd*rR+H_^894m9uEUi~fa=t!_`8Fcc`dkf}1F7~nIo)7n$@q1jp zed)Mi0#|)h_GJsCWp%aLb7g$C*r$sOw6}4?uhcqO^*2ffyqbuG{--oyhkuLG4~|# z3~TYlneXAvw!hia5YNl~eJ)Q{_96TT4{l_iOTe4Ts~hs_PRc))*L^4l>SF5JW-`f5 ziDhy&Xq}y;71!nMhSqA(;#nA(R^DGz?ERB0>g4lx^yWYK*$?2nc8(X}yMY$xR?&{R zhR5_HpglYp`)gp!#I`|)C^yWlRWL6m?U}ZQ&o|tQwS4poqHo11QT<;F9{BytX64Dh zDlX3%$oGsyd7L`F+LUKbqC7n;&*Hc|Uj3l{Q_F^YQp<+*PV5Pd%ZBF*-LjQm6_qW| zvf=yT&3nB$x+s5{r`G4&$z0G@b@~~=LHpW2&5=ida|(*6m#XQf6l5xLEWEl@HNMzu z3?BXQh`yNz9kbs|;bE$w<+i(t@X%uL*zd4^bN&1-!*e!lFD?62e{UXlg7UslmP3WF zEtgw06J0mP1y#}M_BoO|D*NW-s;FGSuWcB zq-_5cI7=NI=`+{8ee_F!vz({lKk4%X>yFSTd;Zt#lYySJN#o-t`D^gW3dcrz`w5gM zUgu8uV=4ObVWg+d%9z5~)}&n1bas=$<5>t%ol$4O`(I&>&FZa*QI}|*;k(#> z%*o_1U+>P*Lzg-ChVjpFut%8h!8{ex+@e(eI>>gO@SuXV_cAYxHx>6)p|9syY$AA{ ziSgdS@^QSCXB$c8*OI@E@DDQTJWO z*I0AnTKEw7<~*v{@P)Kn)+ev%{*Unq==XB4Md4bXZYI}Aw+rd=><<`wx=`EgNDs=b zCBiO6dqun6(1Y^V6Ew5aeVU9h@_2_|RJ%2bHHzZCrGGN)bWaHgyl*1~Penu_AMqTo=cD zrKI6l>NMCh-Wd$vq${(dmwwPEF^8t6Ujn^1ckEzClas#hHgGv!AB@#TaA~*3u*&_(j1|zn`;Ijayo{7#u7S#V> zfiFMx_U63>{70jcW|n=yL$n)jhIb!tUQ^efN+C`-Vb1uQ7;n zabC>jH%VK@dgwO;{0iWcw4{z@Og1U%kN*y|xE@d29MRh`r$j&Gj;h;N$K{LCAx&nn zU#4gt3}r$)$DB{vJeZL^`ml(W$@9I)Gu5}N=1Q}s7kfn(~E8EGOlmz(OosV(@Bnbqr5xy|x!=?!O>h9WIMhE6r(?CmkX-jq>H0@J)|<4k zL_KFNY?P5r@9HCAoojIa0%@V$rP5l^gci~_(7HMp_2*p8n(S=sKdY+m^mF|*Keu#l zIlp3NS*=Kxm-*ZJI0t8j@(cpX5@#n1KGzb}roI>EKqk!F#Sc2B`+5NRkzOBluiMyM z&`Z){n!t%0bZII>Bl2s?@z{RgX6@HZ1D`HV1~}3_749s>{+grHc%AO^8sX$M4$mlV zDBp}GIAx9VvoxGs6C8zk9q=}khBK!L4(Eb^^KWT5bDQ9lHO}5NoCQsA)MUx$D`_~3 zn&9L$&flfsEN+5R)HnlaI7^z~D9rsp20PPmmNvmDXq=nVaL#LjQ`R_tmWFd-6C8zk z9PswOG@QJTqu}>b?>T4Y>aN1rMcN?d_dPhq9)y>%Hs`_TXn2VEP!B%W&`-i)ON2hg zgkF011VSJ4`5t_+p`Y*}6#4+B&n4mTSA>4T9;)*U{e;a{u#-$5Ci)}=pPulj-529I zr@KC^+x_u4o7LqtZo{vZdYGJ64=en7h;Ygp=Ovtr-q7wZ@o}<{xtp&$X3G>+Y1#IC z$$k%Zs8Sc+U0*6HlR7pUqy4cd6Xf8PDT{ivwCD?Yd96?6RTv|$Vw~4Xlh@Z0d8z5} z6>v`GV6u*80FL`LrVviQE!Q6Loj0_;Kw9{ws_mtp<31nM-G(A`Adm6A${kmF)k~3F z_t|yxV716KdROp`Sm#x(3lUt#7>_Qh2(99ArT<9M$Na%B05kO#;RUM_^jD2Rf3KmR zpIZ8Al74w==?7`_FHg{iAJ&xreTKf8R@!CgrnLqE>7sh6c9cE~ScBXOiEqEWgK>-aA&h5zFrhCESClUdrKm3rki|^uj_MjPH9y5)s|<|>{tVv{?c9ur z_6dgeiJ<-UZ~Ap*=~Z#&d;JjR!iMqtA^cP$L+XWU5lSSz-K%&_=qvla74rbfATFTyNFyGv!_K?JzQl@&!$kFXkjf zURt8|pkg=V4#>j1qy1nr&jeNcE-_7;x$~S#@ zO!>@0n-x7IU)(zmzed_2-_7|y1^Cj<^!~;R8u@vA41Q*%)EDRGW+894edxB4-qt>o zlIK5+k>|2zd7^v`dBXnC9+$_cgIO0gmie|Z^8f0bPmEayL&#Igi}p2M-Z!S?y=jcR zZ%iq>Tjn9;IhL%ynv&n;W8}y7*372yn`>`d;V-%GvL1o?Y2K|ng7M*O=;qM1dfv9i zejW2+0p@LFZNkg}_380h)P{n6e^Bvg&RJhki}ii1u*2FOp}%+gsvg!g_1*NNgXl-) z-Sk~Od?#Pv#qx1E&UmrUs(>dTu#d zFfMf8clZ|cG4bx{nyhCaJ?B+*Ic?04H$SX-f)27wgYZu{=N}^8;~#Xs z`?&|gmL+ZNT=>oBqIi#c4W66<0=`1Xk@d*(by**!&{djsX~J${KK?zU=sS=$n6V6P zB97Uo&q%)VSTCc`xx?fkF?>i*9gf$8Csw{2US|0=Or(6(uF}xz#`3*!g5_JCEFaoS zTs}QF{2XI|AzNEFoM)JJ&kFB7xO;`jo;qOn&kkdbA2>TQ)zc7rh;>HDuaJQrns_+g z@nH9p9NyfJ*KRuxVDgIIo8^_q8h@tx+EUlJd6{}cne12#d`9%MH?7d|T(FJ8Gs+ap z#9LpAaDr_pKXj1gcjwpZ%l*A}HS86U_Kuh`H_tZ6lX)q$IiBHs=nS0y3fq4G`v$ld zc^L0Q)K``b>zQ)y1mn@r?({kQc0b&2uWX6+mvLqB>!@SVrvl?m$J3`Ht0#M>hokFJ zdB)N|S!;!!XJ9jW9G<8HTEFeOtFD(-JL8ux$(W-{kNqT0qkuM&zX5kDqs@rz&b_WAF`}^RdogFu zF_){m!OqsvcC5YW@dfr|g6^q??g0F9j&G5EM@F3*(fLvuo!eVSU&5F`_{*OrbS5Y0 z2tWA+5uLl!=-k;l`n0C=48~?cXY{{xIXUNJ<4BKwwc0sk^DCSs>3(L?_3QC=B^F@OR+Y_bLrlLJX(h0Fn0{JX&q_aDN z_y$Yo$uv59Tjl&+X|MT{gw7k&=;YcWI{%zT=h4>Dsg|F@i9)B-(CLrsYj;MqMs)V1 z(b?B(*2b*uGBHYyonze5iO9?9eo$SGJwuo`Mf`D2$E3>{!E#Gwu}M2Y2eb>%wl#i!x>%v@Kn=?Se`T@NUF^-iPxD%l!ftcU6D z_hJ2n?e<|^lL33chYc{@9v{|qG++<V0cSRZ+w?!yKtgBd=ohv{-YY>@oT@nHjm&GljZ)V~EjY>==;KCDLAVjtE| zo~QV*AP3mhz6^Q@yVHmD&jYM2fjb|tB|dC`=^poSyO?goPdCVPc^}rpbkF#(8q=*h znYJWqgMCc5+K2TMcDWDhnGM)RpI$)Ng+8p0uzODN^5`OLlb^1iu%&(;1C-SaAJ#|M z?FktWw$F$4cLDZ-pT_`UQ+#?ogef1^M_7js>t`O*eOQgK79Tc9Sep+ENUz<8brJTW z&tK0Rz*hLMKEf{XVf}=y@?isnt@dGqgkA2#YJ?ShSnwLauJ&PFgst&mJ%p|EVSR+H z_hJ2nJ?O&*2&?+ALBf{$x=|x6@56%E0(PDc>muwzAJ#+I3Ln--*d;!!pRiRvY=E%U zK5US%%Y9glu!0W@P6O;}AJ#?K8Xwm8I>4UtWzbL9QXe)z*ft+FNZ9Q@ESL+}JwB|9 zuseNN4`F2=)<@XgKCGXx?LKUPupK^Zkg%OTtVY-t9~O}3q7UmL>?R-9L)iU3ETC;# z?6;X3(}jMzo({nFoOB)T*r;#~uMf5?I=Aer#r?VDIa)b=7xYgt#+pc4?or}?j_gu3 z&8A<5eSK=Ek#-IDOawV~9n&kbXOqu7bM5W8`+~l!_FwJ!FxvN3+#`lFM)H_HP~}rg zOP<4;nsXjm8NA;1a~Wq>mIWv;#&=v_p2>9Zmv`WsGV6go@M%N%&s@9X{*xM>!)tH& z0{rfuVC*K}qP)UWOQ(_s<}chnAiG=Eq@q4S-Fd$3Q>tMfC&xwwtj*N)Tt$>7cwWY# z(YtzHkBI~D!*T_=nUNp=vCVqT^)x;1h;W#1h&+N#ohw~_Z2nF2ej$zElOEQvIgTQ|+F0}oxk#3820h|`2KWkj z%lUU4t3gM&hQ@g+u7{0FGv5`_e2t;`F+)?%^>TcK8rRRZ`!Yw_M}y0!U{5dfgK5ii zWgjr>KwW6h1Iq5|gUq#jAMwsHaO)fTJ(cq>4KUQr?YOJ4pht!@0T%PFdr;H4SG?6P(;^$!BRA&blTzMUAsC4QG85oKWM; zO2gUM1Sda7cso7~XHyfLvc_pk!`adVM`5lMaXP>Hd`kTko8WMM6*&JV4d;Gjob63;${ObzX*fHY;BY<`<@s_N&dw${WsUQ<1}E?A$q#OyGU~n? zz1|(Dxsp#g4d>1#I0cP!YZ^|u2~Jhxd^io~?j|^x2d50KOT)Rx$5Dk9V#{(kuhA{1 zx>~~vIG@pjuhH-_&SUi8>ohz>?5PJ|Z|EoC8x4KLqx*5R>jwqp5Lw8wo4 zwC`1)rm7}nR9z6s=qw|nKS|06I3lCM>!rK{Y56?j=aaEGRgJSV4QFo?oE+9kP!~6+ z;XDc)mbdtZ()-iChm$?KrNWCu?;|}6-w>7e@FuNiXC=!E94T*cq44oXY5BAyc(*uJ zjk7upr>zN2Zjt13Q5w#aCOBn{b8Z?=dlMY>M#<-mX*eBCaEcmdP8!biCODzSIWY}q zMiZRk>B8GFX*jtiI8}{v_;V??VNMeqb%x~gOd8JICO8F+Gn|IApb1V@<9s&_XHgTJ z{9@tln`tqxHZDs*y_qu(DYSZvC&WrZoQ#3qG`WEdP z-r#d|82U+{W4fWA^f_i2`bpm+XXq#4a}52Y&oS4~Px>4S4E>~UvB=O*!WSF*NuOhh zp`Y|QmKyp=-y(15C*kKA`bnSTLPJ04bF47*lRn2K8XorrXGVR&pIxi_f-hmenXSuU zJ7bY|MEixhm=F7&a7k(3-=)}`eF?qUr}I6(BVj9rT{Yx6H(5DsQFb)DZ z)ij)uCOBn{^Tjlrr<&k|8s~4)aGq|0lYg`D_Q^DyXPV$3zJcZ0o`&;$6C8E6;M|ag z^FkAxqQ?0^8qSMNaMV)C=a15G)T=x{BdVXG##x<))6xV-@ec6Ju8Y!e+M3`LHO{$d zI8&P7gc|3KX*lgoaPsF0Z*$UcI-1~w8t23`oas$)irtdWF=;q6QgJZng*&z&x5Iy% z(iU?~aIoK>IM1Zv%xQvyyTFMvoQ5;E2~Jt#d^ZheK@*%DVzZFXH`8zyHNh!soCniz z7B|7kXC$?%QMdi-x}L+he$TyE~r{ z!&@}m%qPU~HVrrP2{C+%hMW0>7~XE^>%KjPcNqG*Z;#>A4Sn6W$M6}3zV5?gc+SvI z!si(Jx^Iuu&o%UQ-yXvk82Y*okKv09{Um&`p|AV)IQoT|?ej&j*lZO z$m#gF-v!=O+}G%)3*b9)KAm&uoICcujmTIvqNzp_W7Tp?j7K+W8UIc~##}e@ zaPmh*I8Pg#xxkr;wIZb3&?4Y4 zI=b7}QMLR0(Fb#Cr(P$q=UV8vvdO=rb}l?y?ezFF^#tD(F?p)voYy42@A>@-%ZIZp zJ=+?Q@D95 zq-)^$sV2DX30$OWzSv=r%GgF48sN-ruBt0lz-U^Zipsxkk@BfLvJwkDo7RDypZqMDeEY zhs|);(B1TE_eD_*>ccq8&ie*hBOmnjO1-GdS55XifPWeJc=)$BNelRYCDZO~k{0kO z$+X4}HShrV++^AZo6rUPElHcWr%77CXD8D>&?GJ32a`NJ*(5FCZOODFP0|8>_}PSf z!zO6~KPE{RHjuWvL1uuTm`n?Mo0=Bz>B+QrH%SZlA0^Y?(~FN1CJs{O8HEdz+*Md|^@_9&M5q@F~f(`UpN;43`dO*`S@cmjSBJfYqa*Y6of+_Hc4vy%r`(R1 zr)=x4uRVo0D7o+cYyKG!&YlL|g*bw<>JLlGEv(10E z`CpFj(|E4JmAI~A@BZ+(_`c_Gd12!>jg*)K2;fIV5}FOgR+KYRxnTV z4Y6W!o;&Vw^v-jKFZe3xkobkfT><&we>_}OP~XX8Uk3J&?Ha;)W%-u;z02AVbJL>k zy|N877<*>Ugr_Zv_`n_L!sC>n;>*wM2|*kgeX5*0ToyUJmI*cjWuFsr!l;@z} zU3evYN)PTJZY(GHjN^}R$MyHS-c@+_hkFZW-SdH&>a>~l$>+{gtMBQR=Tpv|S^vtw zyCnW;n|erMmRgPgXS;fcds%qq7j$|zeeblrEZCza_lGIi9Cx3J#c}tkd<*^s&o}DA zuixx(X~X&1^s%)JZ46W6y-cEaCO(XDVZrpE66NtA_SoRe0gf~3IP?4@{7c=mEgKDa z=DG2O0-hU!Hidne!gD{`Mp`PnLW`J`vxHB_!W~3E#}qmWkiUH(>J3l())ufNx@d@IRLQK^tn2 z$r0hV0N<4xY;H9h-&qIyJu2VP4}@96C(%G_Ic$6mdTMFAXNQ>h)Ez;wtyDz+mV?du0@{i~`n2;G($fD8(z`lm&-0+( zMfS_Y8V^G6(3a%vq1$yn`+3ikO~6%Z~Pq}_3 z`|wz9{y7|$XYPULxd-mMyC>c~e?x4|-RNgfM)J}8OrE%{H_%0y>D$Kj^K0Vkrit+N zYs%}<3*>&1v1CwxnCJIo?mfI!m7Zgq^Fr9M%dp>bC49+?;jdi;e+@pBE1%SQSg7TN zwlpui0Bw#w-bMJIjQ@-ApM@{F5@-HgmaoKh70i>my2r=_G^DQ11RrNocb47z9Q*?C zC~e#7ygg51T%J((tV8#_1okCX9&Atk88*J$Yuxt=KYF719D?6`5Po!AKBdd|$VBSg zKT~9)dAenD^}Vrd&VF9rQR&(Zw5_qnC5~J;)-Y#0jmsnaAIkqA>LEJk3Hrf(@WLy; zv%X_qt>2c&k7vknABOQCo7w`KAI3Nbpf@e3Yo6)A{G{HS=J(2F-!rCOy%O2`yzv~2 zaphq2{s8)JR|XT&kKbI|dL=UWZR>-RAN-_=%DbW6KRxkw@A_kIeq*=Gxc?HL!D%0v z+p(V>ei{4jJlY`JSlpMzcy3<7&a`u(eEoCNr}hIWHg{~jb7Y;E#~3#+)7}qZ9^>E< zwt076=sE7`!dR<@er^bJ4Z|3(j$jUA-26{-`nAqqz7n6r)w^agh-9tDQWI)ZNgu0k3|XhzN~|Xg!LJ;KU-`28EZEG0 z@GlQwt-$pyrQXN1m5y&e>21kv{zz@|%b+YV#XcmZn^;Pu(>EU-y;J?>PecucV## z9YH=XM^62}Vfq7O(s$Yqe3~PXQ)+*_d*c1j%kyjfb~jOZPt^BJYiAS9@)nRha4D*t2r?J;A7arm=s|9@lM{_p0^Z-?XRnDG^2 zJyKea_D-bzIeA(C68+Y=d0PJxc_-Iv#KtuBFLj%Jc{-8c)vRS55wG^nk_oM4`Syi< z`M7zRx=4;Wy2iA-zrK9Nw(ovE6D^DDgZ3RkIVMWqwa5Kq(s%0L_*N6mBk5a-oqc>F z?c?Ri%q>&!+bq+Q6ED-tYlFXOd1(5KjR}HsFW11{^Fzd>V9d*N>=4JaVXcYH`o<3k z&sS`mik2JDldKL@cgk{DC5q=_??3$-9UI4ZNUlj-g>R%8@XQRnA0of_ z{|4?q5PtCdG2$4$-iv%l`#8`ZLb(IR0pZ*0$v?)YA>tFrKVyCfzYO%>jc+x;Enkd@ z&<>v=M|8zrNf&LKE32oeGuQ2AyA?9f%Ol ze<<~c=P5`pi~|A$++y;$-sVb0K5LR0(A}OJvRWHvKMfF_3W=+W<`{B)B_hZZ*pF{2$>{N*VP?duxVx0$ZNM7AyAJE5;htLL1$XU*Igp3(a zIyxVB61wRbPs+Tr_-^5WjVr|+4qRKeaK@!%u_sA*MfxG|D)}JY<=JBLgdPnc zHWv9-vba;yrIW$FB1=cp$n08e?h+szF~#~j;tvtmT0vZFDO>EtU32peWQtSihY-Gjc8Pen?>-gp>g5&0 z^dEN!cpnB1aj%A5W!ft(ZaE#d1$i=^N})k`ufQuA&Bp5TLy%BkaSM*hNowq>5> zp~ukZ!na^e3t|m)?0X!~Z0BO*^;V$?oujOalr4G0`wG@KpP{qfH@p|w=J*YI=6%Ea zcYdY60WPwJ{nh`_O|2XDJYAoMPVg%awycpzu9NVb-#UvjJ}O$pPtb*Jb7Mpp6+LkEA^`5J|FcnYRge8ZJJ;Wx(NXxWX)V|3*DaS=8rn4U=kvns zQM<~pyF%-x9WyNOk2)gV$!0HXyZt` zpXEmS=g|*Ic`jTwdaO;qI;K4YJ7{TNYV6v#Q?JDwK zX6dbo^P~N{5xm(vAGP!f%SI1@9{ZIzuB~|+{m}EM`!?J$#XHZzgW9I`CTHJGd#d5Q z2HRKFF;?fkXsHYC0YYDD_W;2jR%#eGETvwsU*k9K>ERq7>2psHV95$S;ddEKl~vr$6s+D4f9%W%JP5N zdlx7>itAjs`pgIhBpZQb5Fl%MBrxKk2a;@r1=i66BpHE(1V*ua%^b~)G!y2(*T_EueA8yu&I{I_cs3OCwmTLB z+%rnrJiiOs?~n5q$v1J>u7I+$b{Dv}QD3;`f&FZR9jxMx6Z#E&F7uf-7jg+GCq7SK zE%LdX_R^$nUNF5NbPANa$)oJa3-4>V1ag;WskAR1xo^u$+;{*M$b;A@811mLh-jlfhwm*7p$JF(YhY zstl60k~R|kdUwco4#BUwO53n~n2%yzDOQwu_qpoX`U2omjyiAp^b@dE@(g;xRp>v5 z?jDxMJEuYThG-o(+A{t)-z&7dl&mc_yi~1^gY@rMUj=jnGd5zo5w}h1JfY{O5zuqn zQo!9q%&$Yf;K6_3J1&}ky%w!5>Dn@d{m;PWHPQBh?(f<8z}WU?!~X$% zV=d|br1Q(VTz&)Gi6nJ`UykDj%8D{IyhT1B(q8}{f#KsrmJcI`NUkrz&cKF7a-F7i z!16hc^+%FVZ``E$X^ZQJ#~a1QeNeqmzjJz$@0@zDalmK;hiC(#uQxmlTZ7*}gKWe; z^lBR@ya4`DiI2!MaM)ML{)*>v zo^7YzS|9tWsBi6Dmhql1_SeV{=jPv~?}0tDVAq;q{;H?f$UMyc5;)R2A8lnm@F=%E z9KTGPwSuzg=~}MrU&+T9`ZvyhtYg5`aX{BmG-U#$b-t+sc$7C`Z+*y=eb(UIZ*ZPO znz0u0@L4=F=Ei4~C4Z~nuSoiSoj%BUhWWd|U%k4zXw&!W^a%7|e3S7lZqmNRcP?Hz z2k&S<$8wFkbe=rl@8qvg&%L%1=@rH24$WIRXD!-IdlJzCTgSNkpuNnhQ{Z1}vy`<&EaY@=TCVREa?*k33i}t+du#SJ)^(K5J(MQC+Tzgx< z9c$HJAcn{J3_8cykV4!{nfLxf>e@<-Gd1Ttwy%2T?_9+EY7hEU;CQ~vJ~t+Db}BuN z7J+y4wUpsA^i<05nR*92@N~egPwR0X+-M!{PMi_QcRwJ%{akC3zjDmq7MIT|WkPzC zJL9-~hU}}1mveciW|^!wtU1wU?` zqPL(?$FYjvD4v6FUKOc}uvsoX^;qzrKZr#grY&er(`CR#zerPI-C^#5p?yKIlmTC>Fm@;dNgMxxb3j5S zlUP%5ERx3WV7y(-@j|(n`CobU2e^;a)*tns@zZN~#oeM7H!!^Nm#~LXm&<2>dsHnh z=_c|9l6r6N%%tsz_f_NZDRhkdiZ=dY`hAGDf$cN>z7Oef>>pr%40clui=WAS_BZ1$ z2A6vb@@&>lW)741x!|EZ{MU0MJfjm)eMTpwzImWE5A-in!?UftsS8L;9l)&;NBGcj zxFYrSGV!5t=MeHxUg`thR7-$7b*wrcDM_#H(o==+FUNj-#tCgz{v zzhEp&_FigjpW815+#x4rVSn^EEA0Oe?4Ue@_n;c+{Hpei0_qa&&d?j9HFiU@wmTm) zZKwk-Vb;9nqRg1R+ytZeNKB+LE6KyC9!YP zJ_pZ;1qr>ihW;al-eQxcKMT1A*O~OgNTaNJc+D_%M|2nIH$g9KTe&B%a37-dxrxEr z*uO&B#gjdE(t|AQc)Sm~AZV}*BU?s;p+0qgaIus{49M*dd}C&K6lV&smw1@>IMHVJ{VmT%p&bhI zE9*m>f?1FmVK~zi!Dbs6#zO=P4GcOT!7fRz!KdI3Q}7VIgLKC9jS^D~!s2lC&f@Ug zX(Ja&otNlzh_v1>E?faWU~IJR4D5MM+5a5I<0$ZXR;Y;Q=!^$sN!aIpit#GE0|&oq zc5%37-x+uZiHF|{K*PouPu^F%<`NqQof)w){<0otMVo$k6?7YY1HGkg4Kc2WXRAAC zvrc3D20Sx_ykN1?V+Jshm%*p(=QfO7ROI<6^rOv-@Iw<&i_%DIO_*;m*zeJt5L)A^&Iwe+zcx{M!?R=NGGYj7;ZpYYcf*#3t zl+VGK%lM8mWrH@K7vHI6=3vI(8}+({?MU!p?)4TM3Y-O?;pP|Cdwc_*u~n{bXg8W^ zCp7IuxnN^$InKq5mBZJRnE8DEf(HFD#>)5M*R4C)oKAzW1NJT3%et-H+%ufq*N5Ke zb-+p)mr;M$&G+cy?(orvRE2h7bS3Xd(`_qJk2#M)M?Xh@2%AosK4IC^DZzkKlo-x;gcOf-YCj*tj))Mmi80up2gD=cXZwj(!76c zoy>Pd$oya5q#hf80CmhO;GAIab;OfSG~v5v?-(j>oHL|0y8LA6yNoqk9%oZ6E$A`k zXSF*)19$Y=eAzQKZIA{mTcaTcT$I=QG>fgzp3VH|qGjpmGHEau4jw8!k|fk=K$xRx;}RO)0N+L`@sn zt*(pX(#q$%^Avo;rcakZ-@`L<#~5BI`shi}5~mbY>l2xYrKes@P+|IG26)qsGotK2f``O18V|^{ePDF%RxRd%kj5&&&T6Fz!Pr*s35rH(JB|w(rKX(~^ zrjsAo0=AiT)8GE{@$n1TFVC7^@_#4rT^`ZaYZ-6PJVVWS31^s&Ar|%BM(8KzJ<5mY zq+DH*^FhcnwwC9E%)A<(4?4*87I2QC@6382ntQ?1a4>CJV%!OAx(7r1g4?EvjAdO0 zdhE-6=r77$=AAOufp}K%M@9a4KJy&)81o4K>h|%+r)iyv_PiyAgglX9wY=HA)zn*qlef!#lZek@Waq0htj@cBwS10QGKPBy+0 z=;tf({HlJoZ7hO!w_eI%6nM~YDf0u^>%V8egO+XY$VE7t3A>}JIJ>UkTq2LL3LP(qbY8s-7<{9Uy4wRg zB>kjg6kqlFUAYtTm$2Wt>}mfBbVaQ~dR_?-zlE`O9wfbm5C zjdKdmdhj>fMp!=}#a?1PZNK~A)**JnnS+OBiakIKUdI_mFfY3J)(+B6sA9dGRl@ut zajU9XS5by;8TxX3$B1+HZtP|JI>!T^tvv|w9YoS=EY{z>2j3>-w+fgqMj=rp0MGS9ppJkf4rCj$B{Z1*d*?H(~a$ol{Whq$i2u(pD7 zDw?_&+b^23RjjjVd#j8op=^DM?2ZB_mS6q;<3BO`pzOD`^>0R6x^ z8qt;`{8k8`(VzToNHosSPmHyF9CgGoCOiLS>vp2Qz4?4d%TV-m5BnEu__ zpLlfJ_~S>s`mmN08z}bJvFVhblpl%9e;wsr-U57wj`gwZS4fxd{x+Xqc{}-_-w(f; zyzDc)sPg%hrCE6+=U1-s@+c>vSv_CgnRM%}TV5+C#1gmAcW z)Zckze$mWBZhmkb{YyJXX&UqoU7S&jh2X^0G5X0OCv`z2=U;=IX!o`JV)&jE`METe z`Hr6p3-G-@H?7R~`drv3`XD$yHGwyZ`8fD-5>}X*q*aIdgvatM*}tMJpi_zYAUJ-( zuv=FqjiCu>{CJWyMkb(fVv;nf6VP~hk~GwX+46X0k~G2zXuNs>Vy_wR zS%$55`@mmI#(D8tvWYfyMse)cAJAU`E$E259xVC3f>~e2w2Bqct8LR{&B*c}zIUSc zWbFDc#dc!-=h9V(1G)Ag1h3qi8y~NKDuKt?6=FEBf6?C4H@=4Wf@2@8kK@7`!LzL4 zU<-Z)JjeFk%G^7j+8D3P_^mCMmhj4W6k<`dB}II{nYQ=4+)LjH-^cT(cy7-vZ~3$B ztG4L*V;_BH&{23_t9oa$Okq}XoYF3EAB*D?Jls9v`O0dR{^r{o03RhyM?OI~Es+*n z>>YH`zB_n?2gOfpS=Il0ecVsu{$v&N0ez1U@~1sb;LqMTT*Ch2D(pW7_c#4k6W+^j zy8nzB>i)(Vh_Bov<)L?{Dl->l0+d;$f}0B1mu$kmWPoRdeaR~JCFOnu@`Cv@K`TW! zHbOW2_S@LxQOI3llRM$Bpf5lAUi6>oi-WN3EJyfr=+{_Z>>i)qSD*|=;eQ|D7)89t z{cfDgn~l}DF!rI$McBV};b&gu^)>7}?pdZUv4!tmGiG)KF+8l(hpXs+w``-DmF(N& zcgT77BFga$yo;-TjJ&O8pY9GX?*#JRgS{S>^K?XOSZipZHIq5#(nWo#O}lP=BE+AHSaRk%lSm^dmZ$2 zH{iaJDR*RPP${BZlk(;<$VzY+Uj{FHZk(xp_7S|p75BGZlO@i&o`b%g>b31jd}kWco|<#Bj-N^YQknDbpqrqruqLJsF&;|W{zdq< z^a0)agU?JEbJKMw1Hb4nVZn$#ANCI@hmAnl1GIGo-h5!|V$8^;NBFl<-i0-yPR+O8 zvqN684CLkVy)TXLCx!1r_8fj4${4=k!{V+2tOI|N;9J*a_>RgcQc(wq%yL`*{h>-_A z?|Nt~9urzV8S6R7z@<_6ro?O_K1fsQqE88VP*?db>Ym$SdtpoIV^c3^e=%Q2dkKGv ze2L3BavcS3@Xe%-kbZ!+xI6?0rY71&S-Sa#r(3IrC(KokHr}tE!nlRc!1L=eR-kkG zu8P;b%ky-${pP(XcOGzJ|KHPoPTc-uTJJ}^{#Af4`ksuT2)FTAvTcpWr^r1yj1{>2 zi*9W4^vl?yGU}-^&)hfTmXrQPp7byFV6836!YT5c5%iY*!P6J>=;&?QY=7YLsgo$jjwX=HQp03;gaX z#tYNjXZQsA)5T+7u#Kb8LH51H`#A83|KC0Q$>>u6z2%t`eoJvK+Qs*@{P&F$JZL?> z)rC=yZ6BSy&-&K!+0fC`(6z_BHl*pA9_K0FXEgKQu``vtb68^!VFR*wQJ&ruAnV9} z!47=s70B3)XHsW=!<<{f`ud5j$j96WKUw-H^mIlYhitj;iTn-l=V*`R-N}{ZVeugV z=lE8LN$e-q^~~_7v3HO1z5(F=8gWqXhwvNA-j4lR`|tLb`UkB?HS-SO%Y6C& z1I9LZEvAia@@U5Z_@-ULnEesoTXgI5=LoweQ`K>b$gYT8Lw)q)Ip>_~@$yUQGkE-E z^m(%LPYdq9qCTE#?qQ$Vc|b zU=Gl+``GTs<1U&X%>7AgVc*=b<9>sLxMB-N*2$jyRLDMwTYIh#oh^|5HLka}R@p#yKiUaG4{buVBoj(X}L8~(~Y zF!)utLq_&j>a^btd%a)s4+Vm!4y}?g8E|f+Popl1;$Qy*1H5j;yI?N=*8(Q( zV;`WN#WQuj_%JAQwP_#Q)9mnl5cRz8!X&M?c(fK>l+0(0UiupK%)TWl#|u~wWUQ{! zax6n$^s~ql+Wi=Rl{w?TkFq2#&WExsB3tCY$?F^HO$Zv+pLBJ>l{xou?6@XvH;?<& zZkq9jOkBh{*vIy6Beub&`>D^&o4H#0Dau275o1EkgWjV(Ka28^{xSEHnRk_!hxA33 zX6WT1{eDaH5-$(wAKJY6ULMkC+xpgOeHt=t2#_WpA>*_7{i=Phz}#aN@r?8bjvAhg zPAbpe3SNYcvrWji^k@qbZAZFt%+OJ*$LcxvuuQ}1u>jA>aU0tM&V7Q1cP2>BxBrD# zP2I?+@4^_)S=2q!#(oRS*fujwoQCiF^*MF|??drhlrrXqE{eX7`@=1^j6L7$l;PQf zsLaJtnSZP)YzcH~t!=mwNBU<6Z@!0eJLoJnn9wuj1lw zL_6g^23sfb?Yr@~3*yKM?N5^LKf&1m(MO)=s@2B>HpVeYeT?uY(8mbJ*GCzDmj z`5ez@_Zi#f>FQYtUDbZC9}}q=-|gt5tnm#Wf@9tv-{W7-_?|lT&7QNu*rn`fOGNka z9N?Zdu_Ks^BRHP-V9ph|u|0y1=Ll}>j==G3;bL>XY`%m3koQe`%53&(sR!d--tl3b zA=lXCYw=p%GZx*!!~1rOY@%<=7i}BTa5YcQoy+lL_#QEHUt@#NexFaTCg0FV+RoU9 zyShid(T-S8crOCm2pd4##q%nXHse}k#eAgqPT=E88T&4zX|H|Px(Yws)?sCr;2})% z5WQ<@co;JBAP<*<2fK!8#CvVp*4Xz0C)sB2U2j>Bm^P9>x4xgjSLYcF@=w2zcSB63 z&QXVF(kz+uMuG!y&E1S?e(8-VeEr5G`5G~Nk!QEwVA@8`i*Z|d?nq*kb^D)3nM5AH;=k8M{n;**0vafJd?1J zac0(sXVE|OwVmUM_Z035I-h#Y^{^SY&D2q(Id72$pP#uKZE$eJ9w5C3IGhJvnva2I z%(t00*1(>^AM|B73Y$e9?fEnN&Xv5oMSP4kAI3R^_YvmaPj_owtg|)@rVC2ow+G2Q<#jmv&A_v3oh$jQS z|NX#sIOfb+jAIewuQIB~;fG)!dG=P?gFM>Lk0Q_I4Z0%w+BkjToGR|jv%2Hz2hAoOrN?(Gv9DU$`g6;NZS$Ap9X5=E!yBW#gXW!) zNPZ_-c5RgJm33_z-qZTme;R-M;b{KRv`*#M@yws`KTi7VHaP>ReUForVa>XY{V+qF z96d*!6nRw}BY71gd8O-w^pSlp0s1srKukyW=xiI!x&mt&*e4mE2=LN=4L9PQ&jrv8 zo_&;hRa2!5xraDEKNs~kiK0EZa>TB5j`8z`7(c z-WSVWc08Bx-AJqnXd9~6fY)m@EfX)>8(ZSv+oQ{~AP=d^ zF}!n0f8Yq{vYsK)8gzvQ%-n=LL+9rQi+kRI;5>IW;dT_f1od z`<$aI%fnUFt6u)#H}LM{qrvP453f=~KgW5EM=j4GGR%749uV)qC*8vTo{cy3;_+;I+KF&nE*f_3?P3&hx{eKSn|48{T^yBA6 z^8LyK`hEOxWOqFNy*LW=j_+_#hG$^DmU$e!1=FDO_*K))ysLF)3+Dym29P)N1HS*x zG~%0*#=GzQ<@!39Z=SK<4zAMYF;3oR$4PQd7{?fcjT^mW5ZjH+Fy$>I+h8DlALBGJ< zfzfoHmZPg*R!3aeG}HGZj=a-!8)`?7B9_tNc17+QRocyJ{XDX*lg;cPP=tj{VCcte}lGz z2eq$u+WHit9kK0;{GOzqfwu5$Y%a&DP4D_gcTHk_2Xi)cg0ryc=q4TE9qD*?x9>QJ_*MWeTDz$AI2Y_gZCErZr=EnAH*-p!@fUa z;doC@;Giqx9`W8iHqR}CSnqun?vxp|@9%-9G3-;s>o9%RHS$O6)R_2c#vjdsTmMwP zOXJuSH4>kb5S=Jr9{F^Cy>a|;a}Fx*XW%FF<1?^9=KRl>;g3glC@koBLKwvp_6B^< z59^k10neo|^C)nuIrm-$utX|CF|2^=RdgZoNwBReYL2aBf6bU;MwKX zty{(n%3NmK1v*LGTiOM9Y-1w4!f@pnasZ&&0m=f!0M1ty*!(2CafrXE}W@0zxdR#qKuJ4%d!nRu}9foH5Y^c~4)_dBuIwav4=zJ0HQ zeU~xHxyY>ld49TjCG;3F7$x7d>*XsVKmYG<((l;uo`6LEns-HM&s=y-oqT7MG~GHu zi*;79rl~H%FXqK@oc9^W+KK01FfNA2*Wuqyu(?>%SetMz+6X?Qes=r7?VDz&Z%UYV zT>i}aqmeyQxI>EPsZ9*^FzP~VWXk?!SQ|6WOMUlkXLPSEeQmpk>e|FAY#My|m5gUu znTA(JGW`%_s>hM_;k|p;5d%2NI7kM~sGrPv(L>Mc^P*+e1;1q3mtU)~yK3f*(cHBh z`Bj{~qkoEc9nVUk4~oM(K*ye&!MgABqv+eK0pps`-qF9nr2iei5)&0aAa2_&Xq(*6 zkGXObv_qx-nsssRWIagB9Sc^bRp3zf4)U8B;9&}Q%R1La{hyDyu0}3^Q`QI3emAeN zI>kA&W9RyKz2xF5^cndmdiqTGRIg6brL7rwXL23O`WZtSf_@1l$*aE(?J;MS_Tu$Ku>PV;Uf|;b_P8hS0_t?z_vwF5k+a_)pmXv*6C;ab*s&e?;)Y@9 z&)uP~KhJ7-GkIO{VYy?AzBp`Lg>k=x+z^u^%=!h@GhyQots1kq7M>_`{GGa9&(7gh z8-X`duAqale4?qkpc3#KbEM0;gRpR+!0dRmbwzi7SsRD=hFfo;*T}HE5bG54zNB+@ zJL=EoMU@dV9@gpp+`_Y%E-l{Ob`ZzeK$(j~&qaQ%I(GE8mp6f=IRtlfo zvqfapyrjZk6)vqjG=jMbxa@=2zQley_XUpNoDy(`mBJkdps(-N#9gn5Q*s`XSR3Ed zgG}w-h}bRQ{^(XaN85SB%+ZjArA?aE3(CXl#H@%WVjc3X73*!hPTlD|ncS`!#3Cw;{+U;N(T&JsgR1L5{}tTx%y*wqANj@|BKjLP zhWAn0{x!fuyD)wP2Xuxdc3^PMraV2ICg=$4fj%2;@P3j)Yn8#{94_%n{E~+PbbhPUoyt`IKTE3q_`+@thuE#i#de~;#B=m{M8s$lg-$?cS zSfR~#L9EPPg`VQw9=21rRr{sWu6X$Hc*|9Pee%9~>^O+Os9VJELg#*oSC0rWSBEX|=nDvt=vj zj@JSH&>0o@zMC3V`TE9s{A<9!Y4|rC|7Mo2AO9Ql5z3C%HOT#z!Dk*hyhk1Q`M1BM z`{7EiBbg66y#KNZ`N6aUKmUf!XB>?AEjqu%{NTXP|JvrWADO>K=dT*l`Cm5qe}(*w zcxFFegtnls^*l1NESg8U)?*$4jU~vZ%x3c*in{gJD)nah7S2A7apYfN@@F!CO<}@z zH_k%)XX9Upf0y9jeEho#{}$ulGW=VPf7g|-*Sr^`?FY$wc;M%c8Qy=0dXJ)>LWuW< zIrlZcRs7E<{~Y(wjh}({yw7}Ud|u(&>Sb$oQ>UAGPVP$mtoXc0KMygcHgC=DfZzPV zue!fsEAL_a0oQIQTOb_27S4MLNvDo*{8~7_1x%XtgyYx3kAE7vJ{9LK>+s#{x-+i$ z9>&?Rx&ppCdzO4-TX-*%_lEt?p>6Xy_onc3WX{po?v@xjH`j%3LFx1cI##g7_{S%DY@fA(Ox00U~`#@9ArKE** z%6UR-MFyW3LlK|A@%bEKd=27i2~;3&q7 zz*6io@4Yz!+cOHfHMTy~bDG#g%$ppuqjmLSzrPCIr~H3Eji;LoPxuu+(2q5?+~HB$ z2V4Ht|Ao6$slym+$Izam=!+wu@!V$Eh2NS!R{gEbW2jT^U*UM2FZQIoPN4cJH zV~X@81RrzLn}E+bN@2b`6Fl(wU%{iEgRI{b&$sqWz4(b!i#mP;AFyz!4&UVh9sG*# zjWz3|kgN3zr!{=k%wtM_f6VoFU+I!8SU~N2^lxYCmcQp(cT^04(vZkNUHL|nk-fGGhuTJt&yj%1&TF-{dqj|sQMp+APxek3j zz7nznPk$>q+kkb-dKvR&^!Yr|h4o`<71#i)u0KR&OI|Dp|F6~m2!~)lk{XO8LE1{3$<0tA) zEUFah9zG2D9g_WQ=uS8CwY_1VOFt*<4ZaUNd;!`z+Gzam6d%>-V?>ksh`Ap=o?cs! z_h#{zieq2HIO5)&*kaJ;v*;z>n~wN0c7x@9LRndU34c}FnqSvCr0WE{03Gu2L=WI| z+)mlJG=Tdo`_zRQoe&vYxY4igJ_9=fe>vXEO1^(F4Eo?z)(W)4qo0PYt1BOVM#F#h zPVjmF&x-5*jrx5<+G)HSt8F*z$r9>Qe{nb4Ec$UTo^dbzDCK7PK|48D1Z%I>>rLVS z-^Xc0KI#ANtDx_cRcp20@1smv7w-FzF#tLutCf1)!?Lga`}pI3g}ZwNk9@p>{z<`` ziaJKj9lyNu*T$Qm%LmlRa*5B`m>Xpn$Hw%%FF&1%JzKkH?8GjHV6&S(0RC4%k0hRf zz1(L;--o-kc{l6W9EJ2X`1kG7`@XZ{fjL8;{hx=2u08(qIcn!8$ERX1n7B)UdkyBe z%Rpl(ez{LGFEDo=!GAF4aW|lUc{j^C(?`6orGUCcuUF{!dn4%n^xLHmo&$KJYWd{& zg%8ZJe6W7aBkH?Tub;cnZyZ-#qYDgYz$6~?9^~VmWzjP}U!})}0xrhQOxxC1<~7gR z02*JjUaz8fe+Xo-!Jgax8Ger80HjR3RULKeAAnnMf z(04zbT0D93K66hC z`a8U~B72DJ`{K2gE659o-Al zXOPw=$oLuTdwxj`|1tacOJ&3s5%&W=#uwvg__nGV8-1p%eKh1TRwg*~3pYVVNLSYY z=gbdp!M8@o-Vfi3_HpD~E#G}OgH<|1=k=Ss>K7!2CO%`8_qdw&Fpf<5kC=XL;(F@K zDm6}UaEhk+KG39mqJ2cn=VjiF#{M(!R3nBJ)j{8?{)@LIWT@8S8?j#wDx;|DD13Q| zqu73033;#7G2$WW0iG$B|Mrw_XLSwq^Eywz9tM5jg^0%o4Vuqow(Wl!w>{E5==m1N ze^0%}z1-rGHs;EbfzNZ{^=f#Pfxp>><9?nd1HZt9G)l#bJ@>ay2{( zU6SVz@_z?&Gg*gZVb~$@{+IpVc3uuY!K~ zS;%;nYeO!<9+Q)v0((u|U^Dic@LMpyY9qdf%W;qM3bbMD(JAvjqzBOy~(SR^kn{Rx0F$<@cTa;Vmrh z?wKjHgJ%h-BTH85byu^Qi^;2kEsy8-l)8+JpL;*_*YRh?j$rK66)&qicp2tzjw9X~ zhhJ5mUKtvOKgY3ln|_C=nesGg_Vo(VY zvoi7LB^lc&7tC5c9HNcZFDa4_z%5@Rtk<4ZtYo7w^Jj704d11F1Pi{Y)s86L=qC7Vldk%V4j~3e;ICqGp@f45-^+%l> z+0|96weN=S%FJ|W&I5njVQ+wcAZXTi{r%(9IxgnLOW>!klXC#U6K4&h-Y8vwETnvy z_^}Rwm3SQ+$)~_Uf)^d_{d2T#`|ytjqi~t<3z4 zGPsAGGB}b}=BkV`3iqa?%-^P!S)5U(sLQ;VR%ThUjKX@8wm`l~>gcY*T8!{!yaVLw zw0c#;hxpwX7a#rv@vFSc%7xc!c<93$G@S2>B=Dzc_z>O$Nx-KY`drtz^kMUbe;*F} zE&OXAE9y@*+tAm3TnrBleZAg^;qb47z7L1rA@ube6yw8xAbg0n)8!L>0pa2&yKu~- zgqwN$KrnQE6eIp#as2TmfqIO-0N#n5>C&U0LB9fdhsC$xxy^Zc&aSE3_Gjw6)+i5soad5(mDu>f>4mmiuqvK|Ew(^R{lIK zf8;Fj?SHX#)l>2L@aTMGBxBoeBc81cFgIA)ijNH0Q+HihBlO5kE8|BOJz9jnc281Y z8sRhRwVZt?f4{^}<(sq49sy#gW8-%O!-;yVu4&&G_BxFE@crmR+UmckL;vx-+e~AR zxt1|$#sR9J%l&?i6IlZy@8i%5>P-o_r18gwM&QM7M?D=6Fkh;fA4cp`>)k$oUNd9h zEw0|-o%#{f!FcJ-hUZVPK4(mlZqcDT>dV#8o$k^dis@cs=sx7pRllw6%g{XR;cpFw z$2UQ~Xg}K-f+xEkEYbc@X47@-s7x7dS~ZM4fF)I126s7z>fxx2#0s_&M=hy>w%j92 z+Q2J1czZ}o@IVWArfyhOZgit= z=(5U@O|k}u-H|o;0Ts@zeCdy|2ESv~aDcenDD+Dq1}o=5TMCs=UGw2Ba*ie=|9O)y z`@)8oqQlF+33z#Mb1g5w{W^F#VtJK*nG?&a0rJA$g7gRb(8MtLeYh++ed^X)-UcV& ztuUijPTaGai@IHTYFVcD&GRXBZkwRa?Ts0AqJ1@WvfZ<^-ZcATa>$HTZrw*vr_>ESVcj8p{@S|ta=dKU zb?-IfWiQ9eFTR*PULHJE-Kdjw%U&SIi)T+W#;)*ExJ~4c;N{Q+yquO!;@%t^2T`9j z`arpm$4h9hJ{sAVj4>@d9!cTx_a@-+$axP>XkS)BR*`K1AK@hVc<}aGS$*hr@KKmy z`K%ec((bwMs;#eMg8B;BW7D=E-R?&DPQTP+&51cN?kCLsIB!071a?~Xy8ck_4URId z55F`(9FV`9xtjNxa_io4T))e zW#oy{v$s!R2mY^zsXQ)Kf0?phiD-bDN(X5f#5BOgzhzcS?Yd`f+fPEgSd(2N{d6c80xr&3)!?Sg^Ck8neKO;l${GOmR6nic8{pN4^s}7T z0ZqckZwmBTTZi8nPi(+DW0;e8*5lLE8}(=%&NP_4kG*#9v%$pv-jP@I0K7!__S@3cSW6kH|Jhre4cx$!?~9= znkLV^;2SaeY?gB_B9eRgEm2&z*T{W3`Np__Pb&MZ0pIs!dS-E$`-(_2_7K$>@N5k7 zX{#vDllT3Vk!2KH(YWw&IX54~IyayU@$TtXUFTu*4rxS_vdMUdG?P}*(7K%bgU^)x z=e>2f(`a>{XS=cgtS~OP-yFvdDczsHH~E1LIYFEV_|7^aT` zKP=vxPVAv)w(YFRw5@r5<@tfyw*BSj|MS{*^zAZM4@Yf-O-^ka`h#|$?E4kiL$2Z+ zq39|7Rp4>H;IC@d{%SLA1k%CNtL2@>l{ouD9TM2HfZ_XvgblH;Ou63&Usaq%40w(V z`Scg@y~p38Ju9PcRv=$&8|gL&W23;;brgn2fv;&75_&#mGv+DapRsL~{E|PGI|6+D zZdY){-139`rXbGKoUwlh?V!Gol2^fuxa>wDU@oH2YhSDQ(RcFxL4FEe@v4 z)bGz?{sRr3OZep7rjMQSL2=61h<$&8F?vI<#P*^u70;xBo==N%bk8NE(V$Ho;r$cM zmq&Bi#gHA_`w{TxmMNfK!L42{`=}2YUR|7EZIaihOz{dSb5B~C^%-SGbeWE{G8;3> z;Jz8|@xC{$%;tD_@0i zzT*2h z^}Ly&W%RV@*A4iOd+`o}!%ri0Jh_kXN44j$d$f%R5DS!Xk63gQ?h=q^#F3+CiM0U! z4U7q#xANmuk0 zvkB^4ol>V;*O6}&b$pe2Ri=WTtC?(<%;#C`G1PGsV+L!= zD->)J{YUX7O?_NzSf4JoyK!C0)Fta?;9{M8qUjLUy<9ijbno?g-E7k%NORq6)6?If z*UdIveY;*a+w|TQ(YpEMeP1){Jn!yPocpzF=17()Yrk(^qx*Ip`xfhbS=%mxf9cGb zb>(H1BbR#pTV7Im>|LLG?E;JA=8e?h{eMiadz7wyjq;6z$MiH<$YFl6s`5NfBRA-E>EPX?v#; zC-QITc9KZn*wNk5uZ1Y|ZtNUHa%bo2&bIE>8wa~v*c_xc_U!Cv+0-j3rVSqkBT5?# z!-rFTbH}bW6zb_~+adJgbcdw3w3S+2`7kXw{j5^-Wpz&vgwai*OL}e3AX+AUAn6S(*Sx2F%fuJdncyLV$pzexiBhVIrxdQGVlW5Oap zk4##`C-gg^>ck*~^60h+Ni(s!)Nd38{ol5;qZ@duI|jN+w%d^weOtO+xFQ{sHZ8Yl z-Ksdh)yt<2@XzA!@bak>{ImI1ayG4773cSRus_Am3=k94Aa%LbF}N7~Czwtv}R z)czYvd@BZc`Bpxu<`L zmY0(T%FfO>O%@VqFP|*9`DDROlZ8Y&nZMMleR(D# za>~nCNu<4euYMUTF1}a4j1@QEt6#FMcfy;?L(`~j0Dl9LtR%$3A}%lL<Andv>C3{dci-7*S=TH%X{j?KkJ3UV&bJM>`9>{udAOElT8-0gdE_VPGwtOk=p#R-e`8x) z>-JL1UGZ8$^S!mL6PDRRX{X_U^qJ)!_}I|hF>ni(ds<;2@19aC(;^1sZ!Y!s-`3vO zGq{tBA+8^L<7}p}EQ$ftFRaT}wX_U&>G~xtPK{2>qq7dvs6uzu02aR5gVc0m0Q;>M zQ-=QKJcKlii2gO{b$uOXTG4Px$9mDrv@twVPSQ62hI>lz+3myx|1D0V58O0MB+|)z zslmyYiN#HO={9Rs_W&opdcU&k)3 zS8-bVuR1Rt?>7&2LU1vDoYwf8`Ucv2Ko{d&qoG#T!*L!1U`KieFlog0OsB14!G5-s zI-_iqm$c1BT2!&ql5o<3gLOajXH{QcX}1_AoxY*7tqUy&MC2yJ!^SO)9pAKLM}OM@ z@~MyL7$^3m+u_1>3@QQNI=I~}649}6Q$*~$g(0++NCSuQf$mn+KQP!wQ_467;|vC3 zW@p`wZU+c^+#i=>zR18doN0+Gn3fA&9mm4hf@HR`Pjq|i`ZGc$80B?z#X|>N>~e(6 zGzJfB`8{o|aW?=@uh%T1v|G%kg-A8P(|(qPvK>+5x3u+lP=ke^&3zp`eH{Y`P z{MhAsoaP|X<$8K`BjQOy!=b0O8CriNj1()8;GoO*DF!_<0gex%?T<#kY2 z_@sTVVU_iYVkKKkerPv3(4=_I)a~`)QGX@j))4q~V*8%Nw-b|(AKU*Vz8zpbzF7wN z{L7r3!oOY=ihL6E_2MuMp5ERi8T{)-V+x%N{`DfV7Jq4MhZB6-WsToniCut9Ej*q7 zr5XI&Wls&A4F2sh$j7(Kp;~x4KTe!5(O$bus-cs?zg;%f;Aik}mr=myJS%fpZ%=<) zG@+)#(K%WV)9}f^2N(QkpJ8iTFZN@!S+{&9C&#!S3HR)qSl~Dk&rZi5=XdN2#qdbZ zNq8(b4<6xTy(lI?k7!vZ>a<|QX|177+RGREdJ{m>A5$K&pK(;1IZT&tAqJPI{xbE_2_LCwI z{j=66Mf#YRC9P+=IK656uR0M|A8wa4+7Gp>f6~)_sD>~;3w~`v+OwfQ#+LTU-t5}a zK#2^4o}}Sm2uSKpf=s)x&T2yp-%RkQ7X*WMv?^^BOYj;{RApSU8MZUB@pOKAx$WuFSo}V1S zZ}0BdfjuEhk8o*vTdQVD427m6@fo-In!agF)PE+up?gOUcE=5$psVSLA`3m8cF{CF z4d2=`*k_MBXt?3jWkBc{I8C*ij`(qfV*(0-=fWd94?bPEaBJwg@Pu|Ue?!0RQ{68c z`gJp`TyZYrt{4M)$M|BOZ6wA=f21@h!to;AaSK#)` zvRlk>t--f~PSRg?iw!W;!gb4P;E_E@)@wtB9=>JM=f`-be!tjVpc;6FzC~*8)3;*q z;Td`uEo*#ydpx2BZY%KGYsKKs`M6FynfcZ)YsNZ(q!K&%j^0D+}M$ z+u5;w-NuFeJqvZ%UD>oKBmUdjxeXHn>~_nl)>ejbR&80$yiL7r-Rm}nH*8(7=H@V& z-k3-;fxk_I17XjOu&b@Br*HSdFx=4H4?n7-g+aTpzZd8F!jA5+d$6w`zTrZpHgseA zp`$g_=L1c-u+-Hv*gf#}@X~&u$e)L|qZ22)+@+vSv7IM5T~7!>`OHV_N9?;dFD zUwAeszGvN?e9e>c5Z{|1`aUQr`gc zyE?ji`ocBsZQX6V7qlQiyTT$8@2nktJzZ7?VQC;-yzA1%SHG=uR}BLTZ81$>AJuDX zO`#v6mJa0joC#kx1nsiUy4u@Hy@~pTG0TlqzCbrmUD|(E+|Dg+aB+K4TMdC43C_PV zVkvAX^|dZ)>Feq54^jSdX`9FcVt!qeVlinsY5v&S*F}~LCipv@)}giC-8}>0_O`Ge zUUdHs^v+dLcWS!a#w3?LJ9a=dBSEn_Qg23ncyGr*J9VI=Yp_czC^$>@{H2|P(qB97 zMa;P^oPXz4AwcH8J1-A+l;F#^hVy&6J9mfo_VsXlbPirFV}k`lDQ)yxyY{cMyLBgt zJ_^04d;UYDni&6DK>fRMz^ZFOXGd4ZfK~)Emf6S@{2e%;YT9TKQ}Mb=yOQK6Drwgi zY<-l(K)f!!v;FVbr`JW#)#HRY3nv(zW=w4_!P=Di?h3nbk|DfQE0t~Uy1t%!qi&qY zj!jgN9u#(*wPMSp58WVqI$Avug{Xa{ZZVCi!(t)=rmayw-u@rchY`IyxbHJ5YXnQ! z+R=Yk%#hKmQfpKmDAq#P%om{;aF;?t&oLjT%!{I1Vp1X#a<;k|hvix2f(4u)5RqVA zW|A)T?TqGSPHqc!VxB|f7IC3c=K^_91~nra#!Hh2sX^{^+G+k&Kh0S8x)}0cC z=nDthOWons3m02LQn6-*-H@Ow;0zXAzBS(Dsubg~fTEP@Y<)2}qrROj3veW*A3JH< zWktGwunQy31kU30f*r8fmaYfRAP!dU)$I6wmR}w{KmXGH%NMGh7}BN-rKFKZ49=*k z7H@KLYcKV;!$az}4!fZffitSJa)|M2s@vW+aBo{%cer@r;*f?xD@P~xGE>?YgEJ~L zd^vbE6{e~p{M6P3_xAL4nw8MarQIRj0>VRqYmK$^BlHYDXp14QE_l)d6O6l4pk)w8 zj~hNtReo}f2fYNL+VNPMoxxffU#BxZF=;!a(`ly$XVgmmcQ5G0=(L3+J{)jb;T@$; zd6iyvgD&UsQL`f`qD=6;h^zj zt4i!ce>?0&zeF%)2y<#$zUypt>7ZU2UD|Jc2jM*6@zTLimmAP^$--+v%V1w0W`PB< znGq!XXZXlM%jD}+<&q+)9lFU1sXbT};|NY$Yt$veVro6L=%>eLO8L{{x3{eiPH!5^ zsr;s*r?Y$-thEu>}$ipvThTTO62U|yPI;D3t($*)Vej{!0z6*v(6gm=xPhQ`p-g~rE7az z-&tpcI{JfO{z)WgQGZ*DHcxmj)%iQiJo~>E#lmeGH0W=_Up`AmNs{v(VGnQ9dQ}!p zwxZfFhVDHZXuDhrO8s<4Ez^@LrsF|wxnv;Hs*0@)fgVvErcF(k%c3$V&#uz1o-$5( zN@2zAnoJzeENz94IG$O<$At0BNFOx+t`lhkt&{8Lc%6+`1ra8O7!d?B!7+)2;c%~o zOYkg_3H?rMM}i+24`_{e>e|zPg?Xk$-f<6Vm!q>*^wjiboH;MHe;-;25NQF^4Vw63th39Vbiow=;5%AQ`TG=x8yHhLK1rUJGNWCB474LP7vKG=MEJ zF%SbCxXwTauQzYFfiu}6nCDenH*SgIH;H=DF9RJd3$W{7`X$Nwbj`K^2ABjWc6Rn` z$3hlu^4c@l-L|V2$FeY1bnQ`$kWnh&?`Y}7aZ&6$II?H|i8+NdTe!i8U-lk_D=J2~ zUI`K;fA^aHlgd98)P9lI<}I6U+_3S6J8#)^%MD7eKe^7-D(rwy z&>hk3>g?+2Uf45e?^BpWoV1@#M>jSwb*vQIbqMz}c-b#LN0f*xW9OhT^JeUfv(7(zwPGDB1rtM-LOTeMYpwe_1=hfY>WOR zzw0h;w)AquB?#VorS1ni9$UTfIM|H=4~D#AYSH$N?nT(P4HuyYTNYi~x(JI5ILmm) z0DDy}19rgUd}hb4J2z~)6Q%$~B(?_K&>e%CMt!wVwylUMITQ|J>2HRLeM#{DC?!URM%PH1@17b00L6sJx zKW^J{`wax#xN758K3r-7g<9XY4`NxwY<2c#ZY^PoVJN;7A_Gn^uLt2CwICO}I&s6! z!k)gJv{v2bBn9m%L&>FXArt*qh@SLApr)$;k9CrqF8?#FRK4@u;5_TxS{zMT!!(crBKmJRnspYS++~;Jw&WOom@Zh#Q=AXsV>P>Q%-LAN7Oy6z0rLSRGILWqHnr`1& zxsjgxZ0Ylte=*-lnlU_XFY)8LCi9%68JBH1O*)gQ%WX?6f1l^9cIlBy>||Z8p2Yks zl?8Wk+`8iDq)b@fvVUI1AGOW=-fw=Z=C^aI&i8*`HTkFd?ft1P|FKE_suLQ2_9TDz z8ocRm(B<;qTn^OdTn}M4wMv?|(Mj@@x4F4d6e! z-Yok6xA1eSejj=usc(U4*dqpR``2%;)f0>V#0NB;Sr+jWbb1Z`e1mr?K7D@tdP76U z!mXZI{wE8!{9F9>zoy%@*rRXZmVb-y%fW~L-@>Pr!>Rh^blYq3eL0*i-1e`pheJlM zHhcZ`w1Kbp;4d0@(Sy(bpze1c-@<+T27~YGNv|14R-RTLP6ZD=evTVHmuJBJdSA-G zw{VMZ$SF(T!cWDgwHrRZh1+pq>HF=qa9?hxg3rq67po7UAz=B>g4^-y^Kapnf1gf+ zp?|7z;kVb)$)dmBw5z7x40slP(cl+PlTTj`n++Xb-(K|S+jc!|;M+X;A2;yc|0MV> zGro3t^t0gG3_nl$_y#`Y!S@>Y6CQlCsW%J0*Wmm9L+H^74V_0k_yJRI`|E^1nL)?) z*Jh8tg|9d8EdEWlYB&5_e5((q+wX@ApS~O{ygW&M{CX{)zMM}5UvAnpWDsq;?6_X; z!L1y8d1mQh7To$di!FoZ*V?gD!B1tEEdA*o|9ee)Eq&Ww-=6#MqDSYY2lc#Z*9#_F zwSOoHw{*%M)^NYyUon2yUXQ+o`}i*!eBTZXWzc`xz{?)}S!VrZ``7YcH1vIVmOX#M z;9EW|9iPur!K)c^$l^21;D51!`~CZR>6}X6ipCF_@5y<+fv@-A+cMzo2JZ8J!lQpG zezNr6j;{ufpC`?@2t9ZfzEA&`rs_wZjbbbS2(D0tP>>)Wv``j-E)$ESt+ zd_H0LAM)^v#=bq_!Dkuy`1~w4@IxMcyMe#t!B0G*<@}-tKV3Rc82Td~oe={+;K3K0 zdbhn!_;Ewur;`Qu>-GJj=^j5rhR>%b2|r=@@$vn7?Yw!q@T_)a!L#_ug7=zv-{*h% z9<3*SKb|gra|WGeBj+soKD=z`yyW$Zg;z7+r;DFO$A{Z~oGkp6hqOF>{4DqZ(_SC{ zbm5lIZA$-HJ**n~hdg)|erW8KuP0U?{Qep;exna>F#6`h=V!nz{SlAP^%?k- zI)1%R7&_MPwep#6`pbuB$tMecy`eMR5VrKQ;PW%=WET7pL*MUTA8y2_7H9bLubBOU z29Hk*_vNtOh^OaS z@Wlqd*~9nYR&H7HZ1&`7<+j&@TRI~da9>X>zOQcfLJ?vH0y~-Bc3_pIoS@_d4 z@a=lD=(TIH!C&veE&g&3o+an`-a6M5Q(1ia_*VWt{FkM(*|e)@37Fq)o_uV!-|rTl zWw$pQ``K&|E&sk{$ED#L;xb<6n{Po7~deRa$zrEi2(PsPh#LB^r$D%>B@c+N{ z*JR@r4W1mb;uu-+3L6LL_2@ip`sEQ1e!}R(hzBnlxIceo*@rB9V&ki2kA7Ah@_?~p zKA$fd_%4r5IRoz7J*!ut!QbZ5Id10hLmoWKj=h-SANu})t=H12dh};ytV2%~CtU2& zv2nSg2j83#FUs1FXvo0#_d9I6UNLdMvRALaZ({LZH26NB?WW%K9-XXxD;sb0<&Zfq zn|haf^k*5kU+*g>Zt3&cVDSBV{rIG9ukDvvUcFiSAg9_lpYPFm#K>*B2YzB8qtLOkiWw{%*P^3F;F9`!%gK-!CymGhaB zXW`4`9T7{9GGzTshxp}R0jW@a$*+EAtHI%r_?j9X@E7x^Yvem9mOk595Nw`%BbE6= zpE6-R%%3K|c3}fjJ1?*&we}0(S)K}uQo%r{HujiO6-SNb2L8N$G*^iQ&aQX)f-abv0P@R=DYp; zgc?#$su5Gq1(U=-pq@sV7uAeO;U9oZ^r(p2=JTK#C_p#XlUA%(tGX3=DIc85(Vfa$HO_!XwdjpDjM@lFF(Mj z;oo@%uC;--QA;*iTB(@{JU!ktW-Ld`6Y0Jw6F;pLoMY4U)^elu&gY5sWXU;AKggfe ztcx=0OYi5nWLmj&E|a>f?YA9sy=D%jEcBlqPn>5hj-99C(exxx-{kOJYx$CLB4u|x zXW8S@h*qyOUhDcQcWqxQJmajuN@LFZ^XG2GJ8@G}g)#XU1B zuOanFbH3nM;h#-&F6UoC@;QWONxIJ9TROHjTfgPDSFqiA+vc=O4%?kJvsrog(xyCW z@#$y9^02%#L-y%@0sBS&O_6fC1R(|37s?1#ZaH%Nxz^4I zdY)aJs=d^5>S1lW>}bcBwbR}zTHHe z>Uz`Xvsn>S)mn8gcEhqN-e1NFuA$|k-U*ov{Gmn2$ z^^a=Xh0EOK7NmB3u{B(5t|uB8><_OCm%R0D1}(Zf!j>zww3r)~HHN*XFUrTQJRRM* zj>!@*zthaGi--GrOZVXZd>7T`+uzcT?wTW5(lIZlMqCkZ-0r`*R}&45LG33em`kEe)%~0=eN5RQtP}c#*9KU}5 z?AYGn^j^%DrQhCzk7h%1r50`9Eh(Q)N2~qvna1$>?7(%!t|aV5Nw%JjZd|;BYe@U; zMct;NntHki@D;iEucjV;?9-c*S7joqG|6Kc3`Hxb~O_+iv^YjY~}ja5*%t6^m%_!LO&g zZ2(`Vj0NG>gM40C9I2MypU6*Bn;Lm^d-Cx6qq}GO;0{M8YV&zNSlkp}p53?-&3;>p zShe}MU@Ii!a$JQx`R(9m&GB(5``Lt= zdU!jcOTy=)x1+bs&G-93w824mqj|RaBKawHp017- zd;-@Z`+9gA+P$zl)ez0}0v#oD^PtRTb3;Wv#WqxAHRw2K7H5>aey|~4WSK8qgyHdE8cXJMi zglwS;yn6a^`C?0ZCOXz(`p?R{8-5-xsWf8Or7dm#`uuq9kSn*{M)>~9RiR6baS8or z>(?E<=3S+}t?^_G6d&*Q?z_<2|C_xp0gt1&5}wvv(pWZ!At4uO+sK$8$vrc=>?MTJ zNV0`>Wk$9|vb$n5GqMItGs=u)TkLL@&F*H|{qt|gwK+Ds%Y7$62!R9=NC?CsTp@vw z8$tk+3v!T<&GG;5RlTb2uIU-g$nq)A=W?rGS65fPdiAb)Rh8wN23m?-t(0e@pEyTG zDwE2d4%@<}XY{(LaqkoNrmcO=hV;x}2<(AI)WHYf{*4 zQD4WJb%x~?mG7}VBg;Hb!683Z!%MX@OAR2EPYli@uW$oPOErq@n=Wy{C1q0O44i*m zNai!D`U3Mp{3r0(l}Y!oBjv0ggTGb0U?$y?N9EV?xk7i|qUoGQdBt~Tv#_OU3XiUn zlu??9;a!!FyNBKu64o>9nCAg3um(X(oAEW0tEAS-2 zpH$#jclP@~{QIID(Ld`HxEPw76}X_!2?c&G6@Re;7yW&$0{=V8zgK|^zP(R@@1Xp( z@3Gfk7z2g^pP>9B3S7veixl{Il>br%zDm?nfnP}QeG2>pg4h0Edp(8zzfOU_j`D9- z;KD~Up}^0i{Ff;3VS?YRz=hKPr~()K@)ZUCDk|rcf4A3P@b?Y{egWklQQ(5#?or@k zfPX}R3;pa41upcOCl&bH=)12d@XezB@3q%o@VgELo}&EcD{#ThE>hrW%73W>7y9d7 z1)ib&`xN+_30`}Ny`DlpU#Gx@+}NzZYpI+G1>QjLixqg3;MXc}p_lAc;BTV*`xN+J z61?_(_WBEb%~0TPq5MM%{49b`EAX`hzeIuWB>2q=T-XDTD)7@O|4Rydgy6@&-(LSw zf*T6_H3T10;68#+D{xWHB?^2C<-bFL3%>uP0@o@3D+-*~8tj@6*y}Is!43s3)Qs~L zxUf4eR^USaxmJM-dtt8v7y7_H1wKRdul=CCoT?PCix_?T6Ptg4<3Vev}kH3n4N0ie+@O27Y zC-^xEyq4f23jC!jc)8OG{7HgetibOf_@xT`T7uu9z%L>AqY8Wv!S^Zf^9k;{+TPyH z1V2TA8w58L_$dV6tiW9aKVO0GyPSV-j{<*`;Fl=yI|zQQ0>6~t_bBj-3I3!4pCgK*@Fxj=u>!w`;Fl`! zYYBdb0>6adk1Fsz1mCB?&nLL+I(vIJ6Z{kfZV=p1;HMCLvjTS!{Cowz?|=CB_9*a2 z34VzJzk}e{D)37QevbmbnBY$;@M(g-q`*fAUVFVA59bhESK#Xi-l4#cC-{&8f91b< zxf2TfDS}_5!1ogTBMSUxg5RvbKSJ=m3j891Kc&DY2>yx!A0qhiH`wveLGX17TqpQB z3cQx!BMST_vL~k%_>%;`Sb^U|@Jki=wFJLIfnP%KM-})Ug6|`^uxDQ)`6}e;Z6s%f zeW$|dvCFuT69Ra^o zfs1nQA-K4INx5J5ANG2TDEAjD_jk~}`0hTsKZWoizEk^QUar8Wuq#Eq1zg;3ruPMY z1>8@7haP-Tm?8}FR`~xE*IHMT>n*MxSI==fUGH+e+x0)LyItRK{myl=cB-~nOKAU~ zeMtMP_ATxA+Kui%Xn)d9t_jxk)@-TSUNcwoe`+qN`C!d8H80n!a5uZ7?j7zAxj*K9 z+U@nUd(QF1J@4@B@_fMa1bFUH7>j zcK!XyZf))Hz1kLSRQtax|4sXtcAfS;_aoZZwV!G)YlAhpnt!UfuIB!luhu+L^LWj7 zYiiuOJK}z)``zv<-6we(JpG=3@VwviInOhmkhjk}<^2cm)!y5@Z+P`*y^ndH^tybn z@pbt6eDCmGG z{;B%s>tCq5}{E7!x zJh|f6D~>zv)Z^NY8#r$AxWaM&a`L6eU4Gov$K7>Y=keXgPai*X{J$Q5+wo5x|NY~a zpYXa9&OD*}gx(X9C;aUR|8c@cPx#ac51jDC2``=C*Iqv1jVGRVV$X?NPW+n_|LMg4 zIq|X+uQ>666Q4ctg%jN?U%#?#<%X59l~Ml%EB|HXwJUF0dH2ePSAJ*Zvn!upx#Faz zlY%G3PTG0Wzn=7-ldd8IZ|~`x{-31lKDr9}e#!qw?eFjT`?v7xi*NbZNAdT|x10kR z$W}vBH1eu#&;R#L?k}B%<3ZTgd~93q#!tn2NAaznc_>+ZT zv#a>;_|y4c`d{?1KhCG?rF4CYuKHR0xp?oX4g6l;Nbk}0Qo24xSCJpDXnUc52FEn= z*Lq0E7fyh*64J?#(7%GV658i)gtQ9M8c1koqfZ9y{3b~2Aq63|K*ArEi?;9I;f?&g zggAiTY3Hzu>pXrv=e_)T@xAmq{LvFXe(jd7_dnk6d*r2yx}aS4yX#+{ z{P3q9`}kSmYp#8K&2M`*y!o2nbp7eLt3vM{3Z{Gc`x1Du&;qSjcc=D_`HxK8h@c1!y`WsF+MTUCW zF~=R;;~?`*W+322ed=<-{8Q2U1wEBx^9@r8oD&u2SJS5otX-nqL6~LT)ThI25u5C4 z$TT-F7nJfG!V1_Sb?g{DteN;OJ%FR`;8?j_c5+TnrN{9!QXLPQQ%VmvhuD#L5cs!? z9AiDX{BAe`lOISQ_F=GteZ;xMOltdZrg}zXJ|`2Yj%5IJ_E8sbu)=hH1w+eL9zcPJ^?m z^O-cnw_&@+^0}SqtV_X6fxYRNlNBfOTiR9rm4;L^`^VpQxdw6)A>-^cPMG0!tOLDJ zCVx>K@Rb-pc^Ud$DV0%FqrL;?g^P&H={-y7m&*ol5M46Cn8+m;4;b1YEKZ%77S`{W9N)bjLUPtq=H?`2chN^yy;&dF+6N+p>QmSa zhaN%%-#G9EJg>Ft+K6%>_JEZI;{XN<3;{eO6Z!{A6wM_RIX4P;V>-)NldK}EI+YJ6 zZ^AG$GgVo-%hfH*#|TR}jyH=D3~;JF9FWNZ*Wi#_IjG^wX8!Wy5BOq|m1wWFz%SL? z!X&D!IreBAI;oTQ5zycGZdtcD4=~5j9E1a>8iMLX_yM!L=aHLlT)*D6oFrESkF&g(AK2M4o&5M*UM*25kL1o=P^u!pjPtrRNwYa+j67SBj!Vj_*F z#7`&k7~`7eGl?P}kj!kFWwJlFoy!VM!urwa@4$mlh(aA^vn(Dz0jKBkRy*YrT**0q zM4z5a%z!MLYAV3NwwZA_(3iz<=(!{#V44uJe;@P1sC6h3^HD)iPa1tRx~+J!=Yua5 zV0;uN64MO1#SK%wpH9roLO+<~Y&rXsVRL2zDkqv&guiimpI2-~pMzmMmWG3q=PO3( z2l0VoOmxR$gRzY|MJsU9Vle6`(f@c(sXl>HR7hx^p+5ts{K65-G2u-y955tXLd}mn-JX0P9r$jh#7d85gb81*2eGQ9A+#m%;QdXW1@xK?%9|y*dKEn6TwDSrulw50jPi$ek)68<@ZoTi2ns;gc~8eBtHY63pVcA zIM&iQw{a}oDEeSyAFN~9(@6L=S~*q(eu750gF`I%0X6cF;AgC3fAKT6VUh9E8Z_F9 z@B{SIA2yJ5fNGF__KRY8qeTxx3y`47(ny<~D8}0D1Q137XmKV0b$kR{oyW%jA0B$> zpbn5jPXOxpXlo4>j}PeoC5s=GzlIrGHB|mO&>gppki}uH?QCqwp+e)pWS%toWrmK5 z2Zq}39h@EF(6`BrBd%T4Uq%Q*(b>;oyaT^y?K$D%5M#+ zW?9A^$k}+$A<)wgJzH`);D-xZW!xFIy_HqI z6=l1GwI%pLxHZTGZ!qLgFBtxDW@v2!56Dm=h4l+@i-PM*ZNjoR6AVQ%MVr8Q6qe|j z>~Anco8Y;{M9nT=o++X#a0f(GfmCFEgIy;URHUK`H47Xz<~{Tdea zEE*SR;9Kx|u@~p=~YIE%dt{?`piWTWJE~8Y7DdDCd8c_L z?)X&4!}d%bB1a&)B$7%@!=$FZuB$f-K?!Hz_@LQ>h5AAdTSi-E!a>+Ut!bkL6_}2+ z!R#UU&nAzG@itNdZ_*~JbbgM|#-~|KQs8rO1wPNlCtZZ!80OZHuF9G#G!aMd!>l2j z$CD+P^K=e+4zs{Q<)-P1_;0YoSTFQY)G`4j_-x}}K zH%0op^`S_Y)QrHj!$J%&lAx*xgHno-jfDXV!p;&LhyoGH4iSZiQ7nQiq3j6SfLkEbv}87$PO})cR#z?W>`KQ$lX9k}9ugky`Oqcj=~_0>gl~x3IUypL#>iCSLI|$y zfg!~)RE8N(P^$6_JK@#$g>G$mv*DCO4 z>Q|NF4gDqy(nYzpX|~rkO6_r4iE;#26aZ^ST!&&;JK;^nzqX-HIuG7xex;rKPhih6 zK4;QfKAC`ZK|L7h%Zz&+A`r}(W5LO*=4oQ2s?JT0H_50gm?&KkZx`b%5jK*jH-*~q ze_-k&E;<718ghCRS7G%-@HGxF+f;M~p}EvIvMrLH85d=2z+uMO&Ie@uNctQ$^&@*4 z>{b?E0Qx3_Q23+K7>RF zbD*;&k00VYt-?CD5CCpsJl!_IuLwWE!wf%%$vnBBpYe7_{A|r;aK8$e zaAA%~+yS982m2@CC_DHx1vpcNSb5#aT%caDo-__W<(hTv}y9?fPHI^c(N3qSha+!zFIY)Yhdz+Nioo{G-GE<=tq zy8w+|_}VL3&q;$;zG4!fMM;0BnE9M1Mp3jI{Pj#P2!+P^Jh7y|IXLBYhrX>jtjA`j zaDI4EriK?H0?*uk>#qrlV8hp@CCK4AFI$uI>SHaOE{%lHGzFcUHx%oR$9d!!kO`T} zHri}$q~<#-Nb@K`M8zHG11_oaiGCIHV?x^lV&?SRl~3%*Wn*v{m)@IAHtUoN} z))?`2Zf=e-%OjTGIB?>!)~Xp7-ZD=8+A_xME)!oEB{7uS4NQRTrNTON!M=|w_^{KY zt0J|97^g4+#p7Y|CR!MT;13Kh!HVPm04a=q;D1g>-4Q*Gr(v^*8HFDn5{(8?TXqD^ ztK$?i2x&&l%OJ$K3%3LzBo=sq5h8SWnGI4u6Lbafu?k(0o-@+a3GvrX z+SyVdCyA$)R=^PZ39(Lc9rVG>Yylizd&XJFBOExL%D^tR5Lu|MfIFHwm5}G-Mu^#; z5Ke2?3peF*DcGSKJf&m6uh`&2720kXE9Y-x4fWtPiCevS==0zadoi4h1Wx&EhjBNXnR%obmS`)Mx2Xw!0LP6 zfS_|bP^?qsndWQJdc~ruL(&3Ke<@$(@^9G>uzzj@Wo-9kItekB*-Wyaw?y`&ktc3R z&lP0HEVkKfQ*-Tl$)Zl1n0kq{0Op%Ek#a=f4gB9in$S4U3%oHmgX&(e4fg{nNEXwK zc0d#}49lpzVxE%Q18olWKwRHZ z_~{a<6q|ockB_k{th(gmX>%r(&rKz=N#>1S8c~uJ&`+v^1WpGJV3Pia&6ycg^w+_9 zuJuFFGxSI{F`3(;_fx=xB0XsYaVD!;JW?iB9^WTlkzy3|XYkvWTyQJoP;vv0n}IMs zrgxg{IXB7#4O^B>tC9~I6Ro`AViLQ0Uu2oih9w39KW$;IkHdTo$B(dsH=omxQ{d`R|%FX{8g6&M0PM#^CGu5cAU&Oat{dA2Bo(M;R^u4GqN4+#$> z=_Rm#x$ug}wGVP6n4V{cz+SZ-tn$zja~urDdiCfaxI2csn)ROEO`C^%2R7;P;oj&L zJ?x-XE=-md^*{Hk$#E@Q@3MK+UYWt(+VNf^u)!+{WoB;aEICouOje6@%_w9zW45_EQ$;H?V7 zRS<0Tf~P8a6Wg$t!drKwPmjc+kuKOe1n6zsk;ai!{@X#(7r>Ud96=6b1~I|%anMOq zJX}!GsTP&-itat!`B4Xpq5y#<^>&cECGfR>>YGqhR8ef70OH#UOQ}@7B1colvIKL9 zN~uZZvWlEaU#(nQvG8waeCaJrm1o7kpy8zo zNha{JU!qIkC6Nkpi4`1Y94Q>;`hVkQq!;uoc8}=8v-vUFP0cp8mcY!8z?0A;Hwb^6 zh}YnF%I$thO`ZsQ)SI3pQ>4yhwuC zs#c+$*&YJnR4S5E#Z!vrjoU*;Ya9IC$mFdnbJd z`HO<5=I)WEcsFbsh+BEViX6s$ZD_07qb&%`S(*!0S~753X0V%`rA4vY?zSR%Lzd=2 zlDkKWe#ckQDEmp^aQh+nL}iSA0TVezD-IA z6|ZQ#(f%!9Rhf1b($U~RH;OA8H(5gZi=0mc1rL9w-N~aS<8aWK5;@>3*%xz1QRcBM zC27$sW%^%3Eg?qv9UUY|WdF`hr}H}@@L^;_a0zy>pnsUAi56dthh-^HOWDB`%q%M{3N=TiS zhqTJ&A&!(R>M@=YkqI;rFZ_F~HjyN(b;_Yt-P_cT8T55>-6BTv=zWPfI1HZYz0jk$ zv6UE{*iU8EdDWq0AA=?FO5;!LGYIU1;TOCDTz>XWr*|aup-oL2jJ6GWlimsEkI&?C zGZWTmSesN`_}pNddRSN4$-xT9QCZ=vY{cfMo5`gKmQWpswT7a<#k^^IE6tkU3&fIpL)7iPvrmf+&V7MP>tP3J!lQZm`0~uJrP$jtB!bz;G zqrtwEwR*KyJ!ZG81BtE5UEo3xD@LVd1zM@lxl&rS z;9Fw}KI2ByDJZ2FzD&Bx<{++TPOiJG$T-*^&Lv$fm7_<#Vh*&0;-g*gCEBlvV*~to zuy(Tvg3tAJeP=YD$%QbqGQ|I$+sInnB;g&6>~97yHb*GD#nh8kH>a|=Op0)}Hnp_V z3Hd9@@gu$+#P?)7z_H4Hj5@9T5nF`*C@T$sL6_=}`Jz)D`r}A#2ldBTiXxH2d|N=1 zujb~aL7$CGPEREC_(U$bb4l81;GbY}Iz;hdGLGTg^Wv~B!+!XcwA#QbIm%8xnNRKr zJawq^OQrC{3^!p0EuP+2&a!~*rIdkR-i{a}y${SYhp7^ap69SphLFc%eI3Xh8gbl_ z(|ByTrp+JHM(cV~!6Z=-7Y__iGpG*3MmUp`@tJ%&F|~v^k)RrZpWp_*ft%#hNJkt$ zxqOP9#K&y~bVjh{0BoRv#jr4jRD~OIR*9j)1+*x#!y8{bQeu95EzKB9 zL0@7WL{zP-eNRjHm%7_=wv*Vd) zrx-^aMwrKW2t8T0bKE@P4;T3#v=uN_Ot%a4Smr^ibp#dTqoX2x9QaWp8dpW^v3$kc zebU5-q>!?Xu_Ao5@IcWLd?Su)2K3=>J$~lW<+Uivi}6PLtrU$bCZ80%9e8STmQhvE zmMB08L2!(ns*KdQUP!YXf*-*)o?>5Dh41o1x5bhWB@Dr)HZLv@riR=1hdONbtrU0* zcW}HF%d3)j)7Qm&dbb_SwKY}Ss%AWg$;V`1UfIcaF&>3H55mNnvphdWQBM3TNc;55 zc_YvZm>B}$Qn=R`rz+0IAQr#lK-(ljv>jaSpqQ_RtHMk8fa8U8r^JFy4~f_Lhg!+G zG%Njxd40Y+H;gz_{=s&`O%R)%&mCZ;`LJZzf**-BTIXM`~CysI%i$16X;KrZm%9mC8p^NF`Bigax)N=#0R$RCAfuXx8M_O z^#cw9lTT2)`xC%0^Z|1xrlU9b2S$Lvi=c;8i0EN{yev3YdaQt5R*5OGvwsz+VNr)=*JZWSJ`G|&P*c8SlCbyiOnN6%Z_Aw2W2XjXYNdkh z78Ef88~KsvjtR;6;wHs8ru-B<>RGrn_GA4Ex$zl24kw$zBol2KWwVSo2>Dp4cT#O^ zQ9NX&GeCmBiTcZPSX;zAhpaz8K>!b81uyGT(-lkMsVx-Z^YdmuFKs;0e4?Ny(5LzS zMPbhOEaQRWX)v3{&E99yurt0BT?N~#9UFqtsgr1BryTjiO6FdLfKV4Jmfeqq2N^Ra z;yjbD(pNf60Y!8zgEuFv9rdm@6!c(dOx&l1m!sqcL0{#@BjRmWv4h|!N0m*#6?`A|&!mN6CG-eJW9KHO6WK+eExS5I zVK!phEUS83$@~Dhw57X>=~hD770R!3z>T?`hBKEp?Iek(4IEFQQhbZkl)i3jd`aU8 zRB5h9(Ebuud5F7_DQW~PQfHp_#mTU|0ID-TP z!0{i&d%^x)`p}Zwqe{rZqAPKC7>D^>Zd^_?fmutt71?=m1qQe@xJ@ov>@pDkdEsYD zw{|dp3YRiyZ|7h;l#sr;x2tIE@28b*b1*5}IaaXO3E2lER@B`bogzczjOx6*If7gv zyG!6Dk)o3j81)Lg*e7`w;G33iBRcSaT66edL&ZaTkTwiZ@vy{bM2ug--$G-2+?f9T z!A%i;WT>?%q7O~Z7K#Q>^#Q*NvcoGFNaUz1Wrvp?N%Py`G>#;m62xER{Lg{HQ>ZF` z#o>mhU`af|M$1c?o=A%je*d<%4&mu0y<(`Tqob`&kI%wBiF~ghIKK&pAKM)WeEv+H z?x*as`@WQ@gbHM{GUk+EGjZq*7)1{8Kx}iA`TXZ?u%R+jw}J-SzygrN@iP#K4i4y> zqD}C)n@u{}Jm*y}+bPABY|nO?b|xSjuVS+?d-M$EEY}Q8@T+6`bAC# z6-~9UZNOpTCRmxH8VSq6&kP`IxPq1Z#DXyCgK%&z2>A}}?qR1rMr~Y1 zj;2aBUQ`u)1u@hbQE3=M5`}=(lKg&D@|GTC%Wr=6_| z`nn5pbFjZ^s@MS}rNUUS)od^N8%29@_Jp;!MeI@!n6dYq&0R+4f5~3sn!N+PnwEe# z5{&!X0K@FtvIMepoMi(rT0snsXp?riNe_b3jUe04U(y5a&*>0<#H58>um@Bq$N~eA z2up}NM3Q30ILO6!syojpTMCLXY;Wy51?e+U7;J=N;vBY`VU7sVI?2D4?N~cVTOyK{Cozy}%_&q)_3?oKl{AXFwMFz8qtABiF(B3H$%K7%yXnuB^`?Cj zg24`w%c8%i-gxSW{jhYKJ|jnTrI7$apE;sNwdt==@h1H^a$Hx2Hz~QQ#hYq%9qxJ{ z*{8*LD=|)v(HrNhD&FLNe215az!W^^9P$#MZMi_i2leLa4M(RUMD3l1x zlzu(Y-$7Y#Rd1ki;;@apjlonsP}GJpCT~iA>9wtnzk^xKEn~(d!9OX-JI24o(o;Ez z2$_d=WmEWJJXld+(+<1z5t-4-J0&|G(=jwGOc!N{7 z**r?n;0#9kg$K6vcJ)S_RhB9z5QM5y_T*jr9^ar(@MB02A*Hfs|$ip?Spq^=lWl}toQ9zXv? zl;Bq?z69TDETX3+jxVAw@Kf=>`0`{#7ugTzZ5f1fzhi9X*`|Xmn6V!QDzBs{CIU+- zKQR7+e0GuQ#721{;VejsG1@r28f>WULD1C%Hp+2j$&b@~{||_6vB#MWPNsCWbl6FzR~?Cm zsIuz1?EY{JEE9N1f?Es;0=B*6C#{KbGMJs)6USu;Y+q3DEp}ygWeT);DhVnYFpJ{+ zrOupBVhDK=ZVQp$n$t7%Dj(m2ThEKIZ2_HB5cKBqQ#vcAYZ9K$!jwx|LDrQ73lbU2 zI0!bNWC5nf*i_Ego^H$s=;ZM%iI4CS#RthpaekTzD+S`<^f8o3W%dAVH0ymcsb)O} zYjnq9J9m93KC&Jc#CPU1sU5{u5opF$YOi)yVAH|uI&1Z_g^JEveytg>^)kXj@B!gJ z4knfLim*=rJITuKgLIw+s#H-egBrjyJ{2RPdfY&BZDXoDa!iZb(OYZk^W)=Oa)yJn zkB+3LWB5T1EcUw}>md0mAL)lc`ic&M6ddkq)_dSo#oYKf4NtopRfqkVb?I&8USnw}ESWXyD&4_m@C={8 z`b@g(j_C2}Tz;mogc%zWAN*8&B}p#8z9}ZYw!kjSsoa#lIh|PQNK^6E(e5x_QCWpe zWV5L`8mXrIEHz5^Pf@GL1AADhY$_hXOI^(Owx#oh*@7;QY6Y9%Kyx&ULd(=stCK+0 zSFLeRrCeQVI}4W2qkp~_o$>tSH zNWsM!U*(-=hm%Pp{0;Ja;jnVPFgsaz!-gX2+Ft{jCN*Txn9WM$N`F~*q7sp;tj4e8 z$geW1@j>2Eynw_Dox4olDWehb0zp0p6)%;{hLy*QWpgZtNNw&~D32F0Uy> zTk7kRi8)|+cr25mH7P^O?liD_-WC>qX63Ub<4cwLi}+GgkB0ikss7tCGl|lIga?yi zGnA+U47FoX2hMDuELl5y46Q9IB|+?ZnpnSL7|J@vq1^6tK2k)sN4p6nLLI?SOOsK2I_%MoBAcEs))BU)_&I*&_~3X#o3fiNQ#oqpBr95DAm~Wo z#|X)J3mY9(r>Y(Oq$Ths#$Pajr;9La+lDux&4O7pHkmGt$~oFG<$xzgJ|*$gkL%J^ zYFl#b-Skh0^G8D}-^!A4>vO%=x1rk_mcE;O#fl}GvTMzXi2sNTQ{_Z;Uv@`qz!N`YWf)e5&IXY`ZM$3 z9OKVL_5~QLY`;p2o!X+<7YE-?t>iQndqA^b*1aL4GWFO!|!(}+02pGr?Ao{rH|Sv)1h4pP!Tq>j5| z{0Zb*lJInF+|4uYB%Y3qJEw66>#~@gW{7R>OuxwDj=MuXBT<<)pxSGKZ(H=q#l?%z z1FG@s9}fDGVz-%iIyTO14oYtQ@-zzaC~+VoTO+lDb7N7%wj&CeWG%zZ=C(-kSiefQ>aC_Pl*kCn{^Smk5qxF|Lq|G_clcEMhqm#> zQB|gYirU>Kd*=vkx4?sJcb?N_Gty=YY&zajfdBMe!RA)kRB4`we+=utSQyZ~occc(JAJVDkI99?u~ zjo3|u?bSt*{kSy_#X!L%Cq?$l{RCCMVG9A|Tfqs!U4U2Fs3yXvEQ=NWC-G#I#?x?a zHlKxE@v<}XqpC_b{E>n#$?w9UAh!f){g0GKu>{i9P$D}sk=kygzWGMD^7OXsn)Xm4sE$%$Dix`XWM1FaNuLGW7{UTd24Ex9}{@^=e2utA0qBlS^ zOp$&SPmHDWGr8Q%L}{(+XjK(#{7I~DGFn=l^w48?qIlOLJkh%SM$V^>;fe4h^(uq* zXSVBA@pOJyV)BrTxvF<&2JvEFudqK`GYkJ<5q{djY@Lvxqa}+Um43no!;7@v`8eC2 znS=$tGlztLxC|`o22g_0R01lySiY<|EcHpbPa>b4N3D|l25HzXelnBYd5{myDq61N zypf@l%fTSi^EPZy`xon<1#d?rm6)DM=Xn>SPs5IJ=k10ie#jjwPHRBXZ^4gsqn%dr zqNu7()!rUvYC0ToW|Om)^8%TiHTAdjuH57-+kV2n?-?RsaV#gbg@>P(i}hL_>=g7EqK)>l?Q+P9a86*1HM|? zh@PY#XW~n)={I-ya-gvi6IM1Rboe-)#du1D`3izic$`h4NP3AUGBat|1#fOFm*1gp zYYy`5iLH|5XjmgC_xhjbzylRuAZ#fTh2$>bYY5!Z7UH0Zi%Mqt>~pyG<3nJyD3kof zGilg&(73o*qaHitHM<5TwqV<#;z4I@}~ zK1tB4k>oS#&j298L(>Z_2tvU8de&*C_TY+@@UvE@94F7Rc>H*k6?qN{L+bzCfPakPDm+lWZ< zT0^snZ2|=`f+^5meJWzgoHoHdhoiRG! zMCChR=-G}ha~e@qA0k=>y;RM0)FotsN5fcjU^`_GL$v5q0#Ct?aV8&&#!+8X7c2;4 zRTL(@e~M`3=vu&>eU#C~N_7O8olLtl zAhQq(5`S6%`ZXM?fz>;F0YROlKu7>log&Af8FG;de#~dh=akhOB`Y==tb-&Al3=U zeYxVf>>N{=sDoS0!b~aqk$nz+DLdOSx@y-U5ejjzxH-RPA$AhDxM63 z)-&1hq+5JT3$#InKs&NFUJ&#I(x0C^%D4|oG@<_?J%P5Y1AEqYXJ#h!_!OLW0xJ^q zggMh@V@LaGj@gCU0rYD)XiLl-E2jYne6`YfoE>St?^`?Z?Z)_YI-O$ksKbM?-Y(M> zWMSSm9pGr+;n%J=sdy8|nR2|rn){vlNcZ3fJF+5@O~CpOA@z^|i$>{Dk32zdDPZty zR2m!D{>bKh!VDY;39N^!jDll%#2_TMlkIqkD0a$JG%u3 z>$6a+vODojk^u*ZBpKndmdE^(lUk5WCFjGG@v0P$ua;wU!~~nlcLZK6{JEI#9HS#c zjJxq9V5&+!y-3Vgne~}RKG9>F7hk$rE8xSVSBrKVp=0ui$tM*rt<}>5xzLU-xvk=* z?HFF1^ciu!gQCxD%j9Qf6O+PrSh{vYnAY8eX(KN1@6)`_OgcRY;q%-e#(QyeOL`cE~h#l+Q|=K zR4TrL8)zduiuZ8D*GQjb_#K@SLt?xoQb0NI3&X(x_ygx7^J@TJ@@d#&fh|RZ1?Ron z_@8`H@Nl;ULCPiuRXVhtSLO?QsfsuT`O1E2hypL+Fn-fe2twM96nBCffuo^WL)&B*{_I~7_MF!f}__F zCoqMD;SIb$ow=UfC!km|_RU1fE-#UOvzAtnc<>7eKZvZ~+xpLI8XDZ*9n+(O&3fN( zSF^q;(%(H4=_=~K1y3%ijXdPDZzZPyM1RWjOj2RiqwpWmd1-vkme{6dP0~nD!50BBG!g>3FDjt`U5G zOzg)Jh5&B$h$>pc?uFMWNe0)+5Nu@&UrUp}Ec3xCg)vF-Xw1d|Ca9*U$ zL&8J}MVbb2g#*(AoFYv{I|bh{XgoRdWlK9P9Ei1*IM9Asdu6$^(|=f6#+qClFx6b7GD@SzyCN}h%Rt|7MIBAlX7ZQ5#HL%;cZx# z$GYRP$)$&`B7HL$Drd*+%8bE`O(wg;Y922MTSm~;Sc=b|2l=*RXvC0ynVU+d`5rbH zGH;KIvw0h(*QNSZ*tE*p^s?Gbi;~_W)2@K^R?OdRv?tlXFzt$54no2TI!Lb$Jvxz@ z0=pu*o_L5&x|jE0S26gd@*^FG=At3T!?P{+ks8kli|Uvkv2i$;&n)41O?m!N>jp-b zmi{HYIMZUKvlxe5hT5e-Ns1Ta6_CK^0~j{gV5RZ88(da6QZdHdvUk&BqNl9I$n}r1 zzJ~o-DQ^xX$BnIu@I&#MfEfsFf-4bzGB8Ln6B~)rMpQVu*)6`;O>%(Zjw#H+4VrPu2;|-$FIG%)jJBFw7cv?6;RjCO$ zyMIVd9X=akaxv!;MoMc(Tc~Zky(46V!{IhG9$MSmV1~GnZ3c?6t`c6w&Z|o0c4yhj zNxAk8?H4w+31GQc(-3R#)W}Gina8mybfPN4KPAF#5iR8fUK>sVR;L$;aR^>Ru4fkG zE0#{CVWK9luNwi4oEq2D9lUta~Es5^?-OZ-7(em^_5_G?sCA z3{NVa;9ktbv-lrA{t!>yldu7@PAiYh5E$V&2!^F1TItBM`@-$61N(~V1bk>Qp9UTt(wi@GXfi zT&_rbi`F4ITh&J=!&31h_PYaRmD@ji#&UaXZkz5zVJ_ZZJR^AY>#9gl0$(kyMiLcz z2-~)=*J8Wd2|q*}H!p2%YwFyx*b}HW1(noS;oUlv(_R8UVm=w7wOPCv5EI$cnMCe_ z42#k(Wb#d$!n+YQ&QT0i4!I)HcgT@cGHgov9fIw+PdzM-r}dH{v46k_;HjVEsho>u z!Ez5aFRMaNs9@R6JQ_SjEP!cl+SM|ua()e7&=thpvGwO^(mR2w1YKpD`g8gStYw1> zUkI2_CQ@vRTv%&_Ykia*1^A2?VuAe0!nfSQ<79BxKC*Yzvso(A$0^8$S#)eEjYEW( zXcy?yjGsVb*m=Y<-sWxHvB9Cft#N&*#k#a%sjWOK##68~p3wA7EoE%ETtXS*)|<E5YSG;0fS@{59R{*fdI)JaAfVlAW6SGqnCf0Ys7bbIwRAK#&$?@Im z3;E>wOm=#9ra9?yK{P5+b80#JgRtsa&dnA6du# zSj#`wKiD+Tum8L-jC&ttutHd6+uZ}Ic3L*?G?f&pRqysI}0 z70aYxUji6lIuLalYS>_O5E;tn$=Q4XcC;zV5KHU^AWYZ6|7;{dH)L}&dSP~Y8n#OT zN&)JdnE+^E4z@s;LLB2yd>6-TL&m)4Wl=A|1Cfuu57e1qpJ^D^8^)oW%v54W+Coq4 zzUl1g%%1e5m9#`TJbx-P1-tKOa#_Al4=>zSFW{ruR3e|!>B9mk7XYrHzgcgcJ9u7v zxHr0GH0W|6T<{kO7fi;|-V1Vo28_3bt;ez5e0)fD2K+mZ%Z4Oid4N?5`8v$XNU+4q z473C>F^a6R7dvrF8u_ewADu|#t@rUH?nBK>wZi+c7o(FT3M}ulo*&8;*efc$8~K6l zdtLb)NDMO{Y$?QA%)eL+kHGMB%HPR2S8+W>d7BeBpt0GT(le~({Xo4UKf>cB;ELGztFZg~mF*%6}Eze1C>@3>@3mlqPkk1Hi zskeN@3KZ{&`rDs!yvcU3PPFHs_c^gx9uXWn*#hO|iJlpPO#^_7%X$F5#iPicG^Zmh z#{%c5herw=I@vM*0PH&BRQ{%|yT zX&9NjHum=R7ATKdE&*gU#rFsv$I)!9Cycx4u^jLl*j^33f{#wyx2*Yu&Uy5rDL7Ic z_GduNi2n#6IfbIfNRjEF1?P?Cl(JU;plg*I)j_2pX6a_#&0SoX!McP4<#sPLhQxk4tHn2bZa`G<+V={=m#fxe7G7RTpyI)!mV?-dOT zrJg09Z_A|8IpoLI@dD#r!U;XBJow%wBm;y|z1e*X`pzkz6)yTk*h?r^g{;PRhf(zy z%VZPzInYEV=Y(QX0Hq|Y56n(ZqH;b1yY+F^WTb1;XdG;S-ob&<;q!*N#rJn7<|ct8 zUE3q)^+g7{Mq#iF^+nEe?FoYLho89bNn|F0*k*EiDh=n?&FBd@p2bv#-qFM zW?_33$S%OTsy(^F&8^K4bH~4~j|Aa3>b?S>k(IEB8>P?Mm-^mU!FqK$e3Bgx9&E3j9#Z5iFNIW}6D&5r|Pg!=P)Fh|27 z6UyNI@N6oP%oP-P_sH<*R2nwXQQ%na9_TkKSd_mfX$K29k)!zvd=tx`NGEW0via%w zY%&S=u82OKh91^Ihvx{INbnAw1LG4mt^{))2+;-kcEbVaI(8H+UGUbwHJ;&MLV^xX3_}i6%2G5hT7vyIK zET9W{DYf@@4B=3qz@%b4a$7k^Fb#^wN7GIED4C`y>Ul5^*0~~A52UgKL`q&(!8XnGxwS;fypmX!P zGhjSsaPw5~4P@ZpaxC683`8)6yptmV@{Y6jXXd8UK$E~G5|e=J)Eq}+lBwQ|eog!! zQwQ^0ZKSkFIfby#LAz;a^X$+sS=?JKu?t8lAu0t~As=idmYhhyD9GkSHuy|(0yrcR zt0-q$ay#HbpoUG(HR@p3>Pa9lFo=M>fvRQ;e0W&CkKGOB!{^Z|hvHx{RsseF;tyLx z4HBO=@y1X8VpR}T~#=~1@QFot_KWen}}c{L%rA&5uN!X_-Nz= z&g2yi%XB`UL)nDC?pSOvwoxY+pT2Et-xfFol|fzTS!sgwCP=44It|h)NT))29i&qr zoeb$jNceL@@WrZdOev%6xy^$@KXqR1aRQh=)4?-6E?g0 zNW&m*RpO~BFS+_CiHy-bjyyT0Iail5UQnZ`4)vJ0m2$pRxj33|6F5d2^fL4z8-Yk_ z$;k{F3DA3b0VD}LVz$D-;3)4<(&u8lm{gHYpy-F_mBNW{(#@xx!WW*BZ z4kwyg|Z=Pe^LoUdPb3&EVCrb;}G=aM*9rDsrhc2&6Wd+yGp;3z)RGdPjX?3l2) z3NtWJxb###sl`u3nb@`|@McbdmS0?x;wRSk_7qU}Hw`bkw|I6r=H`@qbYGNjCNpC- z&!l}ucq7|rk1&ta=M!LxOFez1=5oCO(rQTCAe|1W5mGCpO_2H^oek*}NY6nvUxf53 zNH~^tNDYv1tgnaE0%-%Jvmr$xZHCkjX#x^z_}x&(Hn{#Bq_@D|=zh5j5(?pWLwYZy zk3f1F(l8{<^AouK8q)QUZi0kAZh=bjaBLs>@~q|v@e7kKIR8L*Fq+hi*IM0{vRuxE zd2ZZVobZgq!s^4{e0%1vnu}bY?76U$csYvyQ!NbM5c%oRR3@95nwE^xiy##7hGdj~j;d>h;9pzwANM?r3^U$BXJOM|{qH96i zgJ&U#_e%NVG4ml~3Ci;Xo|OvHT6)9Jg*-!$;*gMj&V%%qkVYYmK|-wsX$)!22MOf} zHWg(|7!uNC8zhuH=R-nzMR|m>31yV{em*@8+;#$6j)-=lZViGL`40UFnc*kktiA9d zaS!e7>g+S;kwm%p-0mmd&Kwav$k(7e(|^I?!ULhgg@-|f_cDGqS5!_v@heto+jn}v ziIN_h9Uo8UMWMFmydF`-bD@5>D}fUL#r2PZVx2~*0|qvJTYZll9L(Qfl@pj3e<*Kw z4K@R-GQDypJkDaL*>@;E_%Zk^_D8Zju(bK}VPu{REc_qk;fP$GUHC_Me$h$l_Z7JO zt_9E74zs?}ZDg+x=I;Y>13p+={sQ;F zvoS>gyqE2OcY&+07uk0NJt%OQUl6IBiw3F@y!Y-KMvA3buj=vljQ)NY3W-s5#4r>@!jhfEorS zG0eu2Be#`VU{8LO^qArI&!50N1n&x2FJLoFxMU-*)W5NKgv+NG^IJ)kp>mIt!(e*;Q zsy3pK+lbF5NQghg70P(T!C8>r0_iwNr~{zAxe5}>|4Zm^yvM&6D|JFy-H=e{-2!O< z(pw>+9=jdV+aMtwoDT{6196XdMw}x45Lbv7#KGS{dMBiRfb>t0{sq#%LHfUt7OTGH z%Bd8;!e&QX0QD}^sjytcIsV8`OJ*>;cl49)+R3$m&E!BOdlB;Ta&Vk)l+G<-%ui(s z1)Q!g;e9o&a>ge%>ZX^P8SZIOAXQH|r}-z@|MU1ErXe0;&*;nqy298b;LIdMyfA1p zIY%v~qQxK_8jSajI8+EUjT!JI=)-++_WiQup%F}VodR8XPX%8t^K|@{3HL z8={#T-gU#1Fvx9i5TpzU<=WsN@Eqa1oPKNyHOu~9UoN?mp4!UW3gK$<34asE`D+hR zI*Gn3u2`cQNFGQyMrt7iAfb)20@Cr2aJ*RS`zpBCA^rJSI);N|G;oXthz45VihRY& z7f|Q1-iyBtfTMmY?$s;u92It?-*-TpP!B^LtP4^PB-91ZhO`k4~PwK}e`iz8ezO5p~S}pua1r^E)B$yD0xf zbp2bpR`R|z&qv_Bb0PIXLY;XCQVh~Cq-~H!AiWI|`uqMG()p0aAf+IULz;ke0i;Pt zSxD26@{ndA?Sixi(uI($-z@j{t035Gu=g@nK1zAmOhN4kw5-oq8U0k2`Yw$Qbe zu5EN}r)vjY(d>lxg2;C9O63K4d0kX~7nR>d<#!pp{4Rr+-(~Rfy9{1_m%+>LGI;r2 zRDKtg-$ms|sr)FFAEol6RDP7ok5c(jDnCl)N2&ZMl^><@JE`1GDz}r$?WA%$soYK~ zx0A~4q;fl{+)iF@=ax7Qb5~z{6Ao`zd??EB-yM(Qtt&PhLl)o~j&$P11^JO3xFGlu zFRm_F2!hub1mWWqqxJEMarJoJ%5nn_*~I@E+SJA1n+N;(cLq=@z}!@1h!q%*_Mxfn z8tCWOp%|~oP-H86-m`_bAFiw);mYU&uB_kS%K8nitl!|u`VFqE-{8vnt!E2wKU^7I zz?I4iQh7ltFG%GDsk|VS7o_rnR9=YDSJ6u_I zxU%eUW!d4%vcr{q93aAlu|EBicLyI4QMbsOSu%TWJTevQ*L!VtY>sGH#*u5ZQX zeLZm$&91)aFsFk^-!Qx1-plgEhWYatJ&%d!+xl2V`@7=XF@KEm_jeDl@3EjN7KI+4 znFHrOL_Wfav1X9>=s@@I==T26_;6$x3Bh(h8tEL|#>hi~_du9HJR0lfZNTr^--G2s zz5Ts!>+Txe2BEp-p2P0GD8iKYySn=!1|dEg86NH)7>1Zf`P}^SX#e0q@9xBt7?#C*gRw1>T$e!_zwp~*^AabOqqYZ*kF*Nn9 z7%12+!UOqdT$bnHJut&iEpYH2IKr*@oP($$MRDxHG5FmiPg$S&8+?6JJCWuR=c0)}^qMd+64EvJPVk{r@CBz(4z8JevKLh=2!bP9rcL?4C zlhoTX1vr$khXwPoa=|}|g|ZPf5}!y+I}BwGkLIQz_8aDbcZix<@>@UWvgLX;(>mAs{;F00M{?VaGZ;ahRoC+>Fje~LktP9vE=nt_?-N2;!xAqP9 z4v8o)&K5h4Bft#%5U8ipi3=PS2(fp`zd&lDzjfFgUJ zaVm~UydQ>G%)ShtUq`3$`q_M@X_5m#)WLD9!-LU5?nt(XKK22)M^$Rr&gDr?#J3I& z4aQ*Er~Mvqk0La>xjV{qCM-zEonBbkV!a=tjuOv@dO3#0{QyW3YkquxQ~)jIcAhsB ziN{BygZ=2a1~G^)!B3P!@@{Y_673y658(ZS!@WIN&CR_iq(r_bi2jCI!1MS_bJui+ zT~lxskp&9h0k(_*AnB=Th;`u$U#BzEX>)==$zOojyYb1y4!)kT^lS6QzwHSIN1@l* zQfuB$oFHuma5Ia(+{~8cf!a}o=#zzLH)7dT_$cpbM?U&{0AV2bR`ZTWf!hB*~hLRuR+q1fei)}!; zhkPG{Tj>QTXICbl%d#a!F(>Y2Yypotg7=~m>EzDdaW>zK-(mMS;!->>Js4qg?j~aReQ!Uj9D6U9 z1;I7Lg{0tuSRSLWXl@eu>a@7;f$1M1idYepua{d#@;%8>={ZF^z;h5&z;R_6aE~hs zKt3RcV9)X1Y(EJ_@d3!s6ld`PaW6hFLQRDQlsG-kXay@e!YAfIzRWU)HPVxrgq5iR zeW2HYB$2g%{5_Mi1#sMqp!S6C<5glq+>=li&sk|*iJ1gE2f5dc@yNrhS^OSj1NdWh z-y7YAtI0V%L;l`=Du*d!FA5K0LS^Bt6T<;9O9W zJ_hA&?;pU|XRGLPq*?yFfk{V8B?x9BzS(3;>>GZ^C=X4}i=^hSKSsR`?L; z6SRVom9JX#P{ zAHnXj(wj|7h5E;#p4NJ!)+)IOd(P>LI4;K?hxbNB)E?bi=?cnWs<5CdxQA&=i2VhV z2Lq1te8|A}VL2cw|3p`K??hJsH@O%8o+Dkcd_X%hxnvF|Vn-+*yTCsV_jB1K_V+MY zGXr^qP!spK0FsZ>ontU^fM^NfkRR^lW6Tft=K5W@Css6^gFgy$d>CLp zh4OfT0Ox4tyabkmWpLUW^8*IE*qT8UHIdnwTr52eS^&M5pCZnP3}!4*AjJ>lB-BR` zA(X@JITc!S0(@&W^Nv|il@obTZULY9@{~^Bot+u)P{uSq89}({bGfPy^dHn0kY_OF zNW=@mm6rzcm_)cDkD+29wRhpFQMShfm&eRh;}KE`wv3G}#**uha4ie0>qfR%lphDF zK7Y6se^0~_u;Nku;c5r6ta;)u_JFP@$`Q{Pf5cMnk3wHaJ^ho{+epr6e70%08Er%krx;_G2d zKn7(zcL}oh$4#|_^BbXe@-D(PZzx9Cvde@%me1`3MU@#5j!rIEF<@PY_!qE}7*-(S zib=LimuQB|te#>`rbF18 z@^MSV8n3U?PPs@Md_J(w)O7kd)eFqKk`=3{UQmEo;jC6n#Op!hDO8U)Sg9}ZKSBUj zS_!q2<-oVB1(h!+7*xw)`OC-=8s2ij5O5I;9F+IU_f&d;CsbH`?E2V8@%P!cT&8)n%e5zK zuFxXdRoa`itF^aj*JR-Jqqk8?`y@liJ^DH)(&P-J*H5Pifz+xmD}bZqv@z zKBK)|yIuQA&1bcQ_Bm}-yHiVRcWD=DpVz)$^9Ajl+TGgUYWHZv+PzwhcAvIEyI=EZ zd$oG)0qqp+LG88LBiah>QSEr`>snNMOxvVAt_^8VY9rdWwXF7CZCd+*Hl{tLZPlL9 z+}g9+M(sJxukF*8Yd_Imqy0>Ko%W)3oc5A-g7!3}RoW{xZ_xf!Go}5x=C8EN-5uH$ z?rqvt?seML?!VBkcb}-;;9jlW=pNT@b#K>hbDyDo#(kFdIrmEKPWKw^F82=Y^X_xC zyWLx~d)zMVEAD3PLHDb)N8E4HzV7bU9&`6;-*C5S-*)G<@4F|oAGj~jo^os2^X~Q9 z&)l!pUUZ+S{nFi|{mR|1{o38G{oY;B{^ZVRe|GQG-sw48zsyr(T<)niuJ9~3uJmZe zRh~Z>S9^YCT;sXSxYl!pah>NX<9g3E#tok9j2k`A7@zPwYkbo4ym6D~UgKuZAB|f) zmm8n*Txs0ux!U-&=UU@7&-KP@;kn89tmhWvbDmp`J3Y4^1K5JYd}K`I_++&x6KZ&qKynJr5fX zcpfpn=6TF`(DS(QkmpI`Vb6DsM?60;9`*dt_`2sQ<1x?E#y31aGQR2gvGKU)IpYb> zKI2=S7mO!8KQX@T`Kj?8&(DnSdVX$v&-0@3eb29rA9()L_@U?H#*N;3-<{sq`R?|< z(f38~D&Lp9t9|!+*Z98dJ`?zURH0eEYnceJ^->eLwM@>-(v9 zi|=RNKHty1{k~s#2YfGj2YoMjhkU>EzSZ|DZ_Ia@FXp-27x!G@d#mS4->~N@-&W7n zzHOdseA_+O`bIq0`OfoP?|Yl)2H)E~H~Rk4^GV-ddv5ZLdT#c;YSk^i8qcSEZqKbg z>uW$8(#{>-mh&=egbI_uS#D^?cS>=lPs3;JMSc%yXBo-tz_D3eVlX<2?8H20UN% z8J;isf}VSQJ)ST7T0HmpT0Qssx;$U;g*|(H-JY-dIy?{fHh8|~+vs`F_ZOard}nzc z_PyEji0^FAqrSIzzU~|JJmx#c^9^6b^G#o;=W$=u^MtR>^DSS<^Q5oO^KIW2&v$(7 zp6~iLd%oxE_k7>i>-m9iljn!Nb3IS_nmteZj`#e?cY@~`-&)U)eJ6RI^_}c_&Uc#U zdEZLUK3{|91>Y&2pZH$m`Kj-&%BOpN z?OWyfjc>K*W#1alZ+)-w{LXix=M`V0=l8xdJ^$-_wdW7Mb)G-^nmm8 z7XOXzPx(LLzSaLp_ow|gxo`77;QoyN68G)?2iOyko$iBf4INm|FCA%wbxc@5m6aK5+-|}DMe$s!f``iBO+)w*& zasSBwDfct}TirkQf7<=5|2Fq?{?E9d_uuZ`=fA`Kg8#GbpZGuL{;B^?_s{%yxqt5e zy!#jaFSuXy-|c?Me~_yt7~f-uBp9j&9${xthuiC$~D*5UcKgq+W%a0 zW9@&f`9$r1ulZ!{rE6}gy>`vbwKuN0t2VXz^R?%%{z7ef_1(2+uD++XW%U~{i zwWqGWuhzeMZ|zyDzginz{ZQ>US3O+&*s4cr6RV%7eeLS+)V^!=cWeJ~_4jJeSpEIl zH?96b?dhw3Si5fZi?ubYe_Q*0?GLq=tomc^`&Rv__Wi5=T>F7lPu1Pu@O0h#8-7$* zciJ;`^{4%~Zux1?)&)-6S9jWJFVrnN?I(4oH2k#g_=ca=)i?aS?xcoa)ScDvV%_J~ zyi|ARnqStr8h%xG*P36~eSXbv>R#XQa@}bSzpZO&_+4FN!z*<)4VMMn`sINd{fdA` zzcS#}uL}6}s{^(AHGw+)+CV_RE^v~5ePE^j$-r9ura*&!b0EIzmca0;PX)HFx;3zE z)u#j7SKSsES@oH~d8=*@ylvGT0q?3i11IWt1K+riMoYr|4e~yheX4@Ou3lfj8*i44k^^ zi9ksIRv@f@JMf0nzZ@3&S%g%OPyKLR+>z19q`krMsxxTdQs@3-{J7e{imj%|`ziia? zz_L?TKe+5eYaU*9mT<%SO0|f`TB2p_tih?eWCu_-k;Qe$NSUz z?|Oe$|2^-|>%Z^)Mg0%FFV_Fi`%?W=-e1-~?fq5#kG#LGf5!Wp`X75=u7B41+xq9c zzpH=V`%3*j@9*nh@cwW8PrR2c*H&Dm^6_Su-VrfDf($b2GippwSaYGW)k}SKTqKk?vy6lR|y6nm-Dk?R!K^I+CQE?X) zEhH@W`+T2s?wvCOL;CrA{`t=10k4_&>-|1I-sktZ_nw>j^1xtfM&KV)UlI7H)GGpC zOMPWvC^a+i_0%f^-$=bG@Xgd$1%^|DfqzbYb>Lg6uL=B1>T3fdsab)4O}#qsZ>g^f zd^`2^fzi}Z;NMfP34AB@4T0~bUKRST;k$P)jI<+wH^VFiiFH(yG z|Cw46m`N=S{8#GMz%Ns83;Zhe_P}gvS>V^HcLaWudS~FbsoMf`spWy+rEU+*r&a`h zpL%!T52^PA{+PNmu#j3A_*3e=fj_6-7kDA{{=i~tRbVOgfxzDca&!MSa6|4V12^XO z1oCn}6}Tz)(}6eTekSnd+}=Qb?q>rx=YB5mmfXJ!yfwEkP>}oiz%9972)r%#i-B8n z`vZl!UkViE{(Yc0_sfBj+<`!8?pFd^bH5t6E%zS+x91K9%5wiPa7XSx1@6rKT3}o5 zP@p{b>w)dL-w525`^~_P+~Gh)?mq|a&iz*4p4@*4?93erRObF`;NIMS3*49c?ZExH zqk*d2e-Av6`<=ksbH5vSFn26ao%_AOL%H7%yd(DqftuX$KyB_11G{p66xf~nlwww+8-ImEf-r-3hR`B~uaxBN%o z%Uh-c16zI`_{x@F1irfEKLh`;WhOAV<-Y>|xaF6Df721m%9*X&HYp0L%Dwr zd@T2cz+dJr27bF`DKNj~d|+vd6ZmYf=Oul?p_kl~@b#DMO!&r2niBegeZh*ATHoC( z1HOA!-r?K1@*ZF1$`^h2u1xyxTY1iZ|4Of~YUO$V11mrEzkTJ~{s&hEebp=H{12@> zmH3X8XL4#*x^nicT<@z}8S?L4`MQ7K%AfrESN`Y^uYAvcV5RLd?_7Doe{dz+cW9-@ z*Rrz9_r8@P-}_hg`aZC-)z`Xm!1uwGJA5BnIpq8B$_`)K$`RjRtlaDS$jSr$kFI0@AJ-ezArd$^nKB}-q#QJCG`FtyDwuiKv-YF=BtGD z4}?8Pxc^9aUw3Ztm4w+xK5)eB=F0Vbo|d{xPB*E#P40H!))Ltwk)x~B4uj$&k9R$? z>tQ)ENk09>eAe>Y zW9IN0``WVFyhERO2#@O?>fk)@xSG}SqI=X0r7C>>MfNk)rn7fmPfYxJUtILr<(4D1 zR3hDUT5?XgxKWO-a?@(*se|F<)GAeD*dh~-bc^5B)jQ5I@t$)e$eNwE-%)cBeN=P| zqQ8CX&Z1a@nD9kK8HhfvsCk4cUBeHX($L|qwySyU&~6^pW|Pq^XE%M(;ny@gc8DEac30i>#qfI%-w@Gp z^RY&J2M^Wg)2+OCbgQY^Czq+Mf@7Ns6}hiM-%qQ4>szdpf8F2ehxVI&KO0xr>VlmA zb>sjSkvPDIu%cT4g0}?a+A4=jZr!P>6Fc5KLn=p?N#djs;%8E-VAOu93XglYxK)X> zw9OfB2YAKklWT;%hGUF_*AACM1x-?2HL3p5>HR+lQ+yT*$rX;8#%nlxt!{5q@Y-PR zHJpzx!bAH)yVL;=hp!1wq%XNO$IfQcQLVL;`309Yf;dSpV0mRsQ`>ndi zQfCjM5-BsKzs|m+v}3oCqpPpam6&@!RL3k*X(#HO3VztVsx6Q1M-S`Ex!&{l`}a21 z=nIPa22Wj^d9K{taK`HwxwctzpiVN$hg+f4=ZX3na~qES&Fy+h<;dY9s;}E$e`xnE zdMth`1^t_-9^t+LB-q>0`sxlHRM$F?bJ06;z_zKfX7^XFL&yzQ%2su%qEGFVJLc3G zbB5RF(-6r7T>X|?D`dhZ zdaAZ+|H;)oeQ}TcAJI7!{f0y4D%i7vQD zO^G=zRDSR|azNK}6-SNRDouS~oqZoY>#jZ2<6B9F*w>kJout{xZ#C|Nk{%B4qL+`f zUExKpuC+#sN!KHsU!-~6uxc8`O;R_-?gpJqWp8+O0-kX4xzX@CJ(0GVXA-7g$HKWN zCcmcmeVm|4gX7$BV^U*6eUk}q6(5x<&Ji)?E&Yjm=CGtk>YIDb)cyUixo^z<-FS#I zL*)mbn>6_L>}uGxTgF{=`ZE0)H@paSgDFUfM{YI|Ke8NA_o53=bx}E!_N0EB3^ERe*&ZR8`_dB(ln2TSNEZwy#_}oj&r%;TQ+nMq>Gx1_vP%*A)M;_z=9lOV-KT%UXRh|d;dX(6kWJrBA?d@=s zANBasSQmoByYa$Y3r{a-9F!SUCtaEmorIfN4KOW%K1dODLiOL)r zu{`~*N{e~(#an`GY^dg=PXP~JeMCPCbCG>gh9kM3)7&gcJnH_`H$GASMmM}Sy30g) zrp5iveN#M}x^u@pH9L8_Rx;rJt}NTC9vt%071_&Gd#vVuH}|z+9FeW(Swv^v*>Ih{ zMbK>F#0zJYz9fPV88Yi-ss8fJotD4oaO_P?OxLh8;mYbElB=fWHb_g(R9i+aoiOC= z6*WCc{d2*OH5Vqq|y;(O*k0`qmz@7q6Rs_4Jr}zSFCx-s7!Iyw|8Fs=nLx z)LJ%3zDzf)ngD&M)C!f(D7ov_Sba&Zy$*@++z7XSFO!$X$YP9et#s_&Umw{JeG%zK zU!@ClXE3@KGwHSDZfaxo-CZD+j;4oY{>zQvkzLw#{paaReEg8AB3Ddm4(@#->h}?D z+1INAt*6&CqQ=;9=#d%*L+{BK3CHlZnF`OySt=+us*O>RxT@YP1tHRpp6j|349{L|+_<4e(xETpu;;*Z#ac#0!qaxbt5*$}=+@%x<-l5e)FNV4x+Dfm zBZgOd2Dbl9y2Z7!t+ZBrvaC@}*j>x5VK1@Da_B|snMKj+_+pn$Yo#Y@-4l~PZ6Bo} zsa-Q)j~_V9oK7y?tmdVb$du4sp+wR_4%MPk&qqZsD$ibeR_mG7q-rgZ@a#rtr$fv4 z>8Cl@Y%h@qdxA6$>za(@ca8R?u9cCg>(s`qyo-ld;Knc$dXt{em(tJ@+1rJny7;Y6z4)Zg~w^>_uTaAFH38;?kVF!OeQu!PZ~r8WL(3 zyB~qT;g0=3*nC_3hl|wc0Sgoetl9UO~sQUOaNnfC^tOYv5U&>^gPr^vV2P4?7Wy zVDxDP^e4Rky{4hjeeB0~(0-VQa1Ta3&BOdEmXCV+hwD5seDu>mvR;i=hGDHE_>;gGZhG5yuJCJcBuo51XlfA z+n%+RJS=M4Meo=B-^U*(9It;|l?U$ik}T|U-^sI&wT@&;mB;^mI=IRuZ@N*TT+|B>P1J9v|s%y?YS!%v<#hw2`2?gtVSMN=#l~yuLiiq&C^2 zO``o6Nf+<4#DMWQz7^LI|9|rQA-A)s3yz%rp&H)d-8Eq@iyn~`39r61S3BspcGo<< zmV96R-Xqd^dj8%S{YYYPjb|Cfah`s}Z>GJ{ciGQ0248da;n!ID((WQtoz*SZ?1u6h z!aY*`RUz5&#ilRj&9h#*?mhVML9U%yPfV&&#NDg*^wjg@!6(AfLqG8t*D+16;XP@o z2Psc~Ren9ipdEpy&%K>78c`FaIL~c9p}RxxvJ&sVy`9?u&D%cpTk1>{aUX?LuJh7y zk!LkyB8=QdXbQl6p3#J7KhhW-&no|zh|Lu}cgXkB<@JA3kddjhp0&N0`Jo;g+?`l6 zEAgIxyxy7!URR|)D!tM3#`{^|drigUczq~8aPUZzJzD8ID%Gt5L4D7L%Brb`zN>R? zXp+AiJ}>6G8~a+iu53Nbk&D`Vt|u+mt5jWowOq7{{8qH@9cqL0!JO-EeyIA|EXMKJ zd`VlCw!z&{^7ewO59@H0o&=GQlzeH5KXIcD&gZ@tSVnELFyO6noF-83z411xkVTJ? zLM>NdIRNSnzDhx#PsNs?Wz1Pj?&*7+TYE4l zI}m#g?LR12_=5V5J9!Zs$&36@cLb=n1vhXn3VN*0B-Dt8Ifsn!NRrHonCS45;r+av znz!zFgSZT04BdoxpiVSNmmFFry$kaYG13n6!eKG{VuDeN0e6i;NRc(L4o`Kj=C*Is z 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%0Dyk)NL2R<% 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