/***************************************************************************
*
* GLee.c
* GLee (OpenGL Easy Extension library)        
* Version : 5.4
*
* Copyright (c)2009  Ben Woodhouse  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer as
* the first lines of this file unmodified.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY BEN WOODHOUSE ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL BEN WOODHOUSE BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

* Web: http://elf-stone.com/glee.php
*
* [This file was automatically generated by GLeeGen 7.0
*
***************************************************************************/


#ifdef _MSC_VER
        #pragma optimize( "g", off )
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "GLee.h"

#if defined(__APPLE__) || defined(__APPLE_CC__)
        #include <Carbon/Carbon.h>
#endif

typedef GLuint(*GLEE_LINK_FUNCTION)(void);

GLboolean __GLeeInited=GL_FALSE;

#ifndef _WIN32
        #define __stdcall  /* nothing */
#endif

void * __GLeeGetProcAddress(const char *extname)
{
#ifdef WIN32
        return (void*)wglGetProcAddress(extname);
#elif defined(__APPLE__) || defined(__APPLE_CC__)
    CFBundleRef bundle;
    CFURLRef bundleURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFSTR("/System/Library/Frameworks/OpenGL.framework"), kCFURLPOSIXPathStyle, true);

    CFStringRef functionName = CFStringCreateWithCString(kCFAllocatorDefault, extname, kCFStringEncodingASCII);

    void *function;

    bundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);
    assert(bundle != NULL);

    function = CFBundleGetFunctionPointerForName(bundle, functionName);

    CFRelease(bundleURL);
    CFRelease(functionName);
    CFRelease(bundle);

    return function;
#else
        return (void*)glXGetProcAddressARB((const GLubyte *)extname);
#endif
}




/* Extension querying variables */

GLboolean _GLEE_VERSION_1_2 = GL_FALSE;
GLboolean _GLEE_ARB_imaging = GL_FALSE;
GLboolean _GLEE_VERSION_1_3 = GL_FALSE;
GLboolean _GLEE_VERSION_1_4 = GL_FALSE;
GLboolean _GLEE_VERSION_1_5 = GL_FALSE;
GLboolean _GLEE_VERSION_2_0 = GL_FALSE;
GLboolean _GLEE_VERSION_2_1 = GL_FALSE;
GLboolean _GLEE_VERSION_3_0 = GL_FALSE;
GLboolean _GLEE_ARB_multitexture = GL_FALSE;
GLboolean _GLEE_ARB_transpose_matrix = GL_FALSE;
GLboolean _GLEE_ARB_multisample = GL_FALSE;
GLboolean _GLEE_ARB_texture_env_add = GL_FALSE;
GLboolean _GLEE_ARB_texture_cube_map = GL_FALSE;
GLboolean _GLEE_ARB_texture_compression = GL_FALSE;
GLboolean _GLEE_ARB_texture_border_clamp = GL_FALSE;
GLboolean _GLEE_ARB_point_parameters = GL_FALSE;
GLboolean _GLEE_ARB_vertex_blend = GL_FALSE;
GLboolean _GLEE_ARB_matrix_palette = GL_FALSE;
GLboolean _GLEE_ARB_texture_env_combine = GL_FALSE;
GLboolean _GLEE_ARB_texture_env_crossbar = GL_FALSE;
GLboolean _GLEE_ARB_texture_env_dot3 = GL_FALSE;
GLboolean _GLEE_ARB_texture_mirrored_repeat = GL_FALSE;
GLboolean _GLEE_ARB_depth_texture = GL_FALSE;
GLboolean _GLEE_ARB_shadow = GL_FALSE;
GLboolean _GLEE_ARB_shadow_ambient = GL_FALSE;
GLboolean _GLEE_ARB_window_pos = GL_FALSE;
GLboolean _GLEE_ARB_vertex_program = GL_FALSE;
GLboolean _GLEE_ARB_fragment_program = GL_FALSE;
GLboolean _GLEE_ARB_vertex_buffer_object = GL_FALSE;
GLboolean _GLEE_ARB_occlusion_query = GL_FALSE;
GLboolean _GLEE_ARB_shader_objects = GL_FALSE;
GLboolean _GLEE_ARB_vertex_shader = GL_FALSE;
GLboolean _GLEE_ARB_fragment_shader = GL_FALSE;
GLboolean _GLEE_ARB_shading_language_100 = GL_FALSE;
GLboolean _GLEE_ARB_texture_non_power_of_two = GL_FALSE;
GLboolean _GLEE_ARB_point_sprite = GL_FALSE;
GLboolean _GLEE_ARB_fragment_program_shadow = GL_FALSE;
GLboolean _GLEE_ARB_draw_buffers = GL_FALSE;
GLboolean _GLEE_ARB_texture_rectangle = GL_FALSE;
GLboolean _GLEE_ARB_color_buffer_float = GL_FALSE;
GLboolean _GLEE_ARB_half_float_pixel = GL_FALSE;
GLboolean _GLEE_ARB_texture_float = GL_FALSE;
GLboolean _GLEE_ARB_pixel_buffer_object = GL_FALSE;
GLboolean _GLEE_ARB_depth_buffer_float = GL_FALSE;
GLboolean _GLEE_ARB_draw_instanced = GL_FALSE;
GLboolean _GLEE_ARB_framebuffer_object = GL_FALSE;
GLboolean _GLEE_ARB_framebuffer_sRGB = GL_FALSE;
GLboolean _GLEE_ARB_geometry_shader4 = GL_FALSE;
GLboolean _GLEE_ARB_half_float_vertex = GL_FALSE;
GLboolean _GLEE_ARB_instanced_arrays = GL_FALSE;
GLboolean _GLEE_ARB_map_buffer_range = GL_FALSE;
GLboolean _GLEE_ARB_texture_buffer_object = GL_FALSE;
GLboolean _GLEE_ARB_texture_compression_rgtc = GL_FALSE;
GLboolean _GLEE_ARB_texture_rg = GL_FALSE;
GLboolean _GLEE_ARB_vertex_array_object = GL_FALSE;
GLboolean _GLEE_EXT_abgr = GL_FALSE;
GLboolean _GLEE_EXT_blend_color = GL_FALSE;
GLboolean _GLEE_EXT_polygon_offset = GL_FALSE;
GLboolean _GLEE_EXT_texture = GL_FALSE;
GLboolean _GLEE_EXT_texture3D = GL_FALSE;
GLboolean _GLEE_SGIS_texture_filter4 = GL_FALSE;
GLboolean _GLEE_EXT_subtexture = GL_FALSE;
GLboolean _GLEE_EXT_copy_texture = GL_FALSE;
GLboolean _GLEE_EXT_histogram = GL_FALSE;
GLboolean _GLEE_EXT_convolution = GL_FALSE;
GLboolean _GLEE_SGI_color_matrix = GL_FALSE;
GLboolean _GLEE_SGI_color_table = GL_FALSE;
GLboolean _GLEE_SGIS_pixel_texture = GL_FALSE;
GLboolean _GLEE_SGIX_pixel_texture = GL_FALSE;
GLboolean _GLEE_SGIS_texture4D = GL_FALSE;
GLboolean _GLEE_SGI_texture_color_table = GL_FALSE;
GLboolean _GLEE_EXT_cmyka = GL_FALSE;
GLboolean _GLEE_EXT_texture_object = GL_FALSE;
GLboolean _GLEE_SGIS_detail_texture = GL_FALSE;
GLboolean _GLEE_SGIS_sharpen_texture = GL_FALSE;
GLboolean _GLEE_EXT_packed_pixels = GL_FALSE;
GLboolean _GLEE_SGIS_texture_lod = GL_FALSE;
GLboolean _GLEE_SGIS_multisample = GL_FALSE;
GLboolean _GLEE_EXT_rescale_normal = GL_FALSE;
GLboolean _GLEE_EXT_vertex_array = GL_FALSE;
GLboolean _GLEE_EXT_misc_attribute = GL_FALSE;
GLboolean _GLEE_SGIS_generate_mipmap = GL_FALSE;
GLboolean _GLEE_SGIX_clipmap = GL_FALSE;
GLboolean _GLEE_SGIX_shadow = GL_FALSE;
GLboolean _GLEE_SGIS_texture_edge_clamp = GL_FALSE;
GLboolean _GLEE_SGIS_texture_border_clamp = GL_FALSE;
GLboolean _GLEE_EXT_blend_minmax = GL_FALSE;
GLboolean _GLEE_EXT_blend_subtract = GL_FALSE;
GLboolean _GLEE_EXT_blend_logic_op = GL_FALSE;
GLboolean _GLEE_SGIX_interlace = GL_FALSE;
GLboolean _GLEE_SGIX_pixel_tiles = GL_FALSE;
GLboolean _GLEE_SGIS_texture_select = GL_FALSE;
GLboolean _GLEE_SGIX_sprite = GL_FALSE;
GLboolean _GLEE_SGIX_texture_multi_buffer = GL_FALSE;
GLboolean _GLEE_EXT_point_parameters = GL_FALSE;
GLboolean _GLEE_SGIS_point_parameters = GL_FALSE;
GLboolean _GLEE_SGIX_instruments = GL_FALSE;
GLboolean _GLEE_SGIX_texture_scale_bias = GL_FALSE;
GLboolean _GLEE_SGIX_framezoom = GL_FALSE;
GLboolean _GLEE_SGIX_tag_sample_buffer = GL_FALSE;
GLboolean _GLEE_FfdMaskSGIX = GL_FALSE;
GLboolean _GLEE_SGIX_polynomial_ffd = GL_FALSE;
GLboolean _GLEE_SGIX_reference_plane = GL_FALSE;
GLboolean _GLEE_SGIX_flush_raster = GL_FALSE;
GLboolean _GLEE_SGIX_depth_texture = GL_FALSE;
GLboolean _GLEE_SGIS_fog_function = GL_FALSE;
GLboolean _GLEE_SGIX_fog_offset = GL_FALSE;
GLboolean _GLEE_HP_image_transform = GL_FALSE;
GLboolean _GLEE_HP_convolution_border_modes = GL_FALSE;
GLboolean _GLEE_INGR_palette_buffer = GL_FALSE;
GLboolean _GLEE_SGIX_texture_add_env = GL_FALSE;
GLboolean _GLEE_EXT_color_subtable = GL_FALSE;
GLboolean _GLEE_PGI_vertex_hints = GL_FALSE;
GLboolean _GLEE_PGI_misc_hints = GL_FALSE;
GLboolean _GLEE_EXT_paletted_texture = GL_FALSE;
GLboolean _GLEE_EXT_clip_volume_hint = GL_FALSE;
GLboolean _GLEE_SGIX_list_priority = GL_FALSE;
GLboolean _GLEE_SGIX_ir_instrument1 = GL_FALSE;
GLboolean _GLEE_SGIX_calligraphic_fragment = GL_FALSE;
GLboolean _GLEE_SGIX_texture_lod_bias = GL_FALSE;
GLboolean _GLEE_SGIX_shadow_ambient = GL_FALSE;
GLboolean _GLEE_EXT_index_texture = GL_FALSE;
GLboolean _GLEE_EXT_index_material = GL_FALSE;
GLboolean _GLEE_EXT_index_func = GL_FALSE;
GLboolean _GLEE_EXT_index_array_formats = GL_FALSE;
GLboolean _GLEE_EXT_compiled_vertex_array = GL_FALSE;
GLboolean _GLEE_EXT_cull_vertex = GL_FALSE;
GLboolean _GLEE_SGIX_ycrcb = GL_FALSE;
GLboolean _GLEE_SGIX_fragment_lighting = GL_FALSE;
GLboolean _GLEE_IBM_rasterpos_clip = GL_FALSE;
GLboolean _GLEE_HP_texture_lighting = GL_FALSE;
GLboolean _GLEE_EXT_draw_range_elements = GL_FALSE;
GLboolean _GLEE_WIN_phong_shading = GL_FALSE;
GLboolean _GLEE_WIN_specular_fog = GL_FALSE;
GLboolean _GLEE_EXT_light_texture = GL_FALSE;
GLboolean _GLEE_SGIX_blend_alpha_minmax = GL_FALSE;
GLboolean _GLEE_SGIX_impact_pixel_texture = GL_FALSE;
GLboolean _GLEE_EXT_bgra = GL_FALSE;
GLboolean _GLEE_SGIX_async = GL_FALSE;
GLboolean _GLEE_SGIX_async_pixel = GL_FALSE;
GLboolean _GLEE_SGIX_async_histogram = GL_FALSE;
GLboolean _GLEE_INTEL_texture_scissor = GL_FALSE;
GLboolean _GLEE_INTEL_parallel_arrays = GL_FALSE;
GLboolean _GLEE_HP_occlusion_test = GL_FALSE;
GLboolean _GLEE_EXT_pixel_transform = GL_FALSE;
GLboolean _GLEE_EXT_pixel_transform_color_table = GL_FALSE;
GLboolean _GLEE_EXT_shared_texture_palette = GL_FALSE;
GLboolean _GLEE_EXT_separate_specular_color = GL_FALSE;
GLboolean _GLEE_EXT_secondary_color = GL_FALSE;
GLboolean _GLEE_EXT_texture_perturb_normal = GL_FALSE;
GLboolean _GLEE_EXT_multi_draw_arrays = GL_FALSE;
GLboolean _GLEE_EXT_fog_coord = GL_FALSE;
GLboolean _GLEE_REND_screen_coordinates = GL_FALSE;
GLboolean _GLEE_EXT_coordinate_frame = GL_FALSE;
GLboolean _GLEE_EXT_texture_env_combine = GL_FALSE;
GLboolean _GLEE_APPLE_specular_vector = GL_FALSE;
GLboolean _GLEE_APPLE_transform_hint = GL_FALSE;
GLboolean _GLEE_SGIX_fog_scale = GL_FALSE;
GLboolean _GLEE_SUNX_constant_data = GL_FALSE;
GLboolean _GLEE_SUN_global_alpha = GL_FALSE;
GLboolean _GLEE_SUN_triangle_list = GL_FALSE;
GLboolean _GLEE_SUN_vertex = GL_FALSE;
GLboolean _GLEE_EXT_blend_func_separate = GL_FALSE;
GLboolean _GLEE_INGR_color_clamp = GL_FALSE;
GLboolean _GLEE_INGR_interlace_read = GL_FALSE;
GLboolean _GLEE_EXT_stencil_wrap = GL_FALSE;
GLboolean _GLEE_EXT_422_pixels = GL_FALSE;
GLboolean _GLEE_NV_texgen_reflection = GL_FALSE;
GLboolean _GLEE_EXT_texture_cube_map = GL_FALSE;
GLboolean _GLEE_SUN_convolution_border_modes = GL_FALSE;
GLboolean _GLEE_EXT_texture_env_add = GL_FALSE;
GLboolean _GLEE_EXT_texture_lod_bias = GL_FALSE;
GLboolean _GLEE_EXT_texture_filter_anisotropic = GL_FALSE;
GLboolean _GLEE_EXT_vertex_weighting = GL_FALSE;
GLboolean _GLEE_NV_light_max_exponent = GL_FALSE;
GLboolean _GLEE_NV_vertex_array_range = GL_FALSE;
GLboolean _GLEE_NV_register_combiners = GL_FALSE;
GLboolean _GLEE_NV_fog_distance = GL_FALSE;
GLboolean _GLEE_NV_texgen_emboss = GL_FALSE;
GLboolean _GLEE_NV_blend_square = GL_FALSE;
GLboolean _GLEE_NV_texture_env_combine4 = GL_FALSE;
GLboolean _GLEE_MESA_resize_buffers = GL_FALSE;
GLboolean _GLEE_MESA_window_pos = GL_FALSE;
GLboolean _GLEE_EXT_texture_compression_s3tc = GL_FALSE;
GLboolean _GLEE_IBM_cull_vertex = GL_FALSE;
GLboolean _GLEE_IBM_multimode_draw_arrays = GL_FALSE;
GLboolean _GLEE_IBM_vertex_array_lists = GL_FALSE;
GLboolean _GLEE_SGIX_subsample = GL_FALSE;
GLboolean _GLEE_SGIX_ycrcb_subsample = GL_FALSE;
GLboolean _GLEE_SGIX_ycrcba = GL_FALSE;
GLboolean _GLEE_SGI_depth_pass_instrument = GL_FALSE;
GLboolean _GLEE_3DFX_texture_compression_FXT1 = GL_FALSE;
GLboolean _GLEE_3DFX_multisample = GL_FALSE;
GLboolean _GLEE_3DFX_tbuffer = GL_FALSE;
GLboolean _GLEE_EXT_multisample = GL_FALSE;
GLboolean _GLEE_SGIX_vertex_preclip = GL_FALSE;
GLboolean _GLEE_SGIX_convolution_accuracy = GL_FALSE;
GLboolean _GLEE_SGIX_resample = GL_FALSE;
GLboolean _GLEE_SGIS_point_line_texgen = GL_FALSE;
GLboolean _GLEE_SGIS_texture_color_mask = GL_FALSE;
GLboolean _GLEE_EXT_texture_env_dot3 = GL_FALSE;
GLboolean _GLEE_ATI_texture_mirror_once = GL_FALSE;
GLboolean _GLEE_NV_fence = GL_FALSE;
GLboolean _GLEE_IBM_texture_mirrored_repeat = GL_FALSE;
GLboolean _GLEE_NV_evaluators = GL_FALSE;
GLboolean _GLEE_NV_packed_depth_stencil = GL_FALSE;
GLboolean _GLEE_NV_register_combiners2 = GL_FALSE;
GLboolean _GLEE_NV_texture_compression_vtc = GL_FALSE;
GLboolean _GLEE_NV_texture_rectangle = GL_FALSE;
GLboolean _GLEE_NV_texture_shader = GL_FALSE;
GLboolean _GLEE_NV_texture_shader2 = GL_FALSE;
GLboolean _GLEE_NV_vertex_array_range2 = GL_FALSE;
GLboolean _GLEE_NV_vertex_program = GL_FALSE;
GLboolean _GLEE_SGIX_texture_coordinate_clamp = GL_FALSE;
GLboolean _GLEE_SGIX_scalebias_hint = GL_FALSE;
GLboolean _GLEE_OML_interlace = GL_FALSE;
GLboolean _GLEE_OML_subsample = GL_FALSE;
GLboolean _GLEE_OML_resample = GL_FALSE;
GLboolean _GLEE_NV_copy_depth_to_color = GL_FALSE;
GLboolean _GLEE_ATI_envmap_bumpmap = GL_FALSE;
GLboolean _GLEE_ATI_fragment_shader = GL_FALSE;
GLboolean _GLEE_ATI_pn_triangles = GL_FALSE;
GLboolean _GLEE_ATI_vertex_array_object = GL_FALSE;
GLboolean _GLEE_EXT_vertex_shader = GL_FALSE;
GLboolean _GLEE_ATI_vertex_streams = GL_FALSE;
GLboolean _GLEE_ATI_element_array = GL_FALSE;
GLboolean _GLEE_SUN_mesh_array = GL_FALSE;
GLboolean _GLEE_SUN_slice_accum = GL_FALSE;
GLboolean _GLEE_NV_multisample_filter_hint = GL_FALSE;
GLboolean _GLEE_NV_depth_clamp = GL_FALSE;
GLboolean _GLEE_NV_occlusion_query = GL_FALSE;
GLboolean _GLEE_NV_point_sprite = GL_FALSE;
GLboolean _GLEE_NV_texture_shader3 = GL_FALSE;
GLboolean _GLEE_NV_vertex_program1_1 = GL_FALSE;
GLboolean _GLEE_EXT_shadow_funcs = GL_FALSE;
GLboolean _GLEE_EXT_stencil_two_side = GL_FALSE;
GLboolean _GLEE_ATI_text_fragment_shader = GL_FALSE;
GLboolean _GLEE_APPLE_client_storage = GL_FALSE;
GLboolean _GLEE_APPLE_element_array = GL_FALSE;
GLboolean _GLEE_APPLE_fence = GL_FALSE;
GLboolean _GLEE_APPLE_vertex_array_object = GL_FALSE;
GLboolean _GLEE_APPLE_vertex_array_range = GL_FALSE;
GLboolean _GLEE_APPLE_ycbcr_422 = GL_FALSE;
GLboolean _GLEE_S3_s3tc = GL_FALSE;
GLboolean _GLEE_ATI_draw_buffers = GL_FALSE;
GLboolean _GLEE_ATI_pixel_format_float = GL_FALSE;
GLboolean _GLEE_ATI_texture_env_combine3 = GL_FALSE;
GLboolean _GLEE_ATI_texture_float = GL_FALSE;
GLboolean _GLEE_NV_float_buffer = GL_FALSE;
GLboolean _GLEE_NV_fragment_program = GL_FALSE;
GLboolean _GLEE_NV_half_float = GL_FALSE;
GLboolean _GLEE_NV_pixel_data_range = GL_FALSE;
GLboolean _GLEE_NV_primitive_restart = GL_FALSE;
GLboolean _GLEE_NV_texture_expand_normal = GL_FALSE;
GLboolean _GLEE_NV_vertex_program2 = GL_FALSE;
GLboolean _GLEE_ATI_map_object_buffer = GL_FALSE;
GLboolean _GLEE_ATI_separate_stencil = GL_FALSE;
GLboolean _GLEE_ATI_vertex_attrib_array_object = GL_FALSE;
GLboolean _GLEE_OES_read_format = GL_FALSE;
GLboolean _GLEE_EXT_depth_bounds_test = GL_FALSE;
GLboolean _GLEE_EXT_texture_mirror_clamp = GL_FALSE;
GLboolean _GLEE_EXT_blend_equation_separate = GL_FALSE;
GLboolean _GLEE_MESA_pack_invert = GL_FALSE;
GLboolean _GLEE_MESA_ycbcr_texture = GL_FALSE;
GLboolean _GLEE_EXT_pixel_buffer_object = GL_FALSE;
GLboolean _GLEE_NV_fragment_program_option = GL_FALSE;
GLboolean _GLEE_NV_fragment_program2 = GL_FALSE;
GLboolean _GLEE_NV_vertex_program2_option = GL_FALSE;
GLboolean _GLEE_NV_vertex_program3 = GL_FALSE;
GLboolean _GLEE_EXT_framebuffer_object = GL_FALSE;
GLboolean _GLEE_GREMEDY_string_marker = GL_FALSE;
GLboolean _GLEE_EXT_packed_depth_stencil = GL_FALSE;
GLboolean _GLEE_EXT_stencil_clear_tag = GL_FALSE;
GLboolean _GLEE_EXT_texture_sRGB = GL_FALSE;
GLboolean _GLEE_EXT_framebuffer_blit = GL_FALSE;
GLboolean _GLEE_EXT_framebuffer_multisample = GL_FALSE;
GLboolean _GLEE_MESAX_texture_stack = GL_FALSE;
GLboolean _GLEE_EXT_timer_query = GL_FALSE;
GLboolean _GLEE_EXT_gpu_program_parameters = GL_FALSE;
GLboolean _GLEE_APPLE_flush_buffer_range = GL_FALSE;
GLboolean _GLEE_EXT_gpu_shader4 = GL_FALSE;
GLboolean _GLEE_EXT_draw_instanced = GL_FALSE;
GLboolean _GLEE_EXT_packed_float = GL_FALSE;
GLboolean _GLEE_EXT_texture_array = GL_FALSE;
GLboolean _GLEE_EXT_texture_buffer_object = GL_FALSE;
GLboolean _GLEE_EXT_texture_compression_latc = GL_FALSE;
GLboolean _GLEE_EXT_texture_compression_rgtc = GL_FALSE;
GLboolean _GLEE_EXT_texture_shared_exponent = GL_FALSE;
GLboolean _GLEE_NV_depth_buffer_float = GL_FALSE;
GLboolean _GLEE_NV_framebuffer_multisample_coverage = GL_FALSE;
GLboolean _GLEE_EXT_framebuffer_sRGB = GL_FALSE;
GLboolean _GLEE_NV_geometry_shader4 = GL_FALSE;
GLboolean _GLEE_NV_parameter_buffer_object = GL_FALSE;
GLboolean _GLEE_EXT_draw_buffers2 = GL_FALSE;
GLboolean _GLEE_NV_transform_feedback = GL_FALSE;
GLboolean _GLEE_EXT_bindable_uniform = GL_FALSE;
GLboolean _GLEE_EXT_texture_integer = GL_FALSE;
GLboolean _GLEE_GREMEDY_frame_terminator = GL_FALSE;
GLboolean _GLEE_NV_conditional_render = GL_FALSE;
GLboolean _GLEE_NV_present_video = GL_FALSE;
GLboolean _GLEE_EXT_transform_feedback = GL_FALSE;
GLboolean _GLEE_EXT_direct_state_access = GL_FALSE;
GLboolean _GLEE_EXT_vertex_array_bgra = GL_FALSE;
GLboolean _GLEE_EXT_texture_swizzle = GL_FALSE;
GLboolean _GLEE_NV_explicit_multisample = GL_FALSE;
GLboolean _GLEE_NV_transform_feedback2 = GL_FALSE;
GLboolean _GLEE_SGIX_texture_select = GL_FALSE;
GLboolean _GLEE_INGR_blend_func_separate = GL_FALSE;
GLboolean _GLEE_SGIX_depth_pass_instrument = GL_FALSE;
GLboolean _GLEE_SGIX_igloo_interface = GL_FALSE;
GLboolean _GLEE_EXT_fragment_lighting = GL_FALSE;
GLboolean _GLEE_EXT_geometry_shader4 = GL_FALSE;
GLboolean _GLEE_EXT_scene_marker = GL_FALSE;
GLboolean _GLEE_EXT_texture_compression_dxt1 = GL_FALSE;
GLboolean _GLEE_EXT_texture_env = GL_FALSE;
GLboolean _GLEE_IBM_static_data = GL_FALSE;
GLboolean _GLEE_NV_gpu_program4 = GL_FALSE;
GLboolean _GLEE_OES_byte_coordinates = GL_FALSE;
GLboolean _GLEE_OES_compressed_paletted_texture = GL_FALSE;
GLboolean _GLEE_OES_single_precision = GL_FALSE;
GLboolean _GLEE_SGIX_pixel_texture_bits = GL_FALSE;
GLboolean _GLEE_SGIX_texture_range = GL_FALSE;

/*  GL Extension names */

char __GLeeGLExtensionNames[322][39]={
    "GL_VERSION_1_2",
    "GL_ARB_imaging",
    "GL_VERSION_1_3",
    "GL_VERSION_1_4",
    "GL_VERSION_1_5",
    "GL_VERSION_2_0",
    "GL_VERSION_2_1",
    "GL_VERSION_3_0",
    "GL_ARB_multitexture",
    "GL_ARB_transpose_matrix",
    "GL_ARB_multisample",
    "GL_ARB_texture_env_add",
    "GL_ARB_texture_cube_map",
    "GL_ARB_texture_compression",
    "GL_ARB_texture_border_clamp",
    "GL_ARB_point_parameters",
    "GL_ARB_vertex_blend",
    "GL_ARB_matrix_palette",
    "GL_ARB_texture_env_combine",
    "GL_ARB_texture_env_crossbar",
    "GL_ARB_texture_env_dot3",
    "GL_ARB_texture_mirrored_repeat",
    "GL_ARB_depth_texture",
    "GL_ARB_shadow",
    "GL_ARB_shadow_ambient",
    "GL_ARB_window_pos",
    "GL_ARB_vertex_program",
    "GL_ARB_fragment_program",
    "GL_ARB_vertex_buffer_object",
    "GL_ARB_occlusion_query",
    "GL_ARB_shader_objects",
    "GL_ARB_vertex_shader",
    "GL_ARB_fragment_shader",
    "GL_ARB_shading_language_100",
    "GL_ARB_texture_non_power_of_two",
    "GL_ARB_point_sprite",
    "GL_ARB_fragment_program_shadow",
    "GL_ARB_draw_buffers",
    "GL_ARB_texture_rectangle",
    "GL_ARB_color_buffer_float",
    "GL_ARB_half_float_pixel",
    "GL_ARB_texture_float",
    "GL_ARB_pixel_buffer_object",
    "GL_ARB_depth_buffer_float",
    "GL_ARB_draw_instanced",
    "GL_ARB_framebuffer_object",
    "GL_ARB_framebuffer_sRGB",
    "GL_ARB_geometry_shader4",
    "GL_ARB_half_float_vertex",
    "GL_ARB_instanced_arrays",
    "GL_ARB_map_buffer_range",
    "GL_ARB_texture_buffer_object",
    "GL_ARB_texture_compression_rgtc",
    "GL_ARB_texture_rg",
    "GL_ARB_vertex_array_object",
    "GL_EXT_abgr",
    "GL_EXT_blend_color",
    "GL_EXT_polygon_offset",
    "GL_EXT_texture",
    "GL_EXT_texture3D",
    "GL_SGIS_texture_filter4",
    "GL_EXT_subtexture",
    "GL_EXT_copy_texture",
    "GL_EXT_histogram",
    "GL_EXT_convolution",
    "GL_SGI_color_matrix",
    "GL_SGI_color_table",
    "GL_SGIS_pixel_texture",
    "GL_SGIX_pixel_texture",
    "GL_SGIS_texture4D",
    "GL_SGI_texture_color_table",
    "GL_EXT_cmyka",
    "GL_EXT_texture_object",
    "GL_SGIS_detail_texture",
    "GL_SGIS_sharpen_texture",
    "GL_EXT_packed_pixels",
    "GL_SGIS_texture_lod",
    "GL_SGIS_multisample",
    "GL_EXT_rescale_normal",
    "GL_EXT_vertex_array",
    "GL_EXT_misc_attribute",
    "GL_SGIS_generate_mipmap",
    "GL_SGIX_clipmap",
    "GL_SGIX_shadow",
    "GL_SGIS_texture_edge_clamp",
    "GL_SGIS_texture_border_clamp",
    "GL_EXT_blend_minmax",
    "GL_EXT_blend_subtract",
    "GL_EXT_blend_logic_op",
    "GL_SGIX_interlace",
    "GL_SGIX_pixel_tiles",
    "GL_SGIS_texture_select",
    "GL_SGIX_sprite",
    "GL_SGIX_texture_multi_buffer",
    "GL_EXT_point_parameters",
    "GL_SGIS_point_parameters",
    "GL_SGIX_instruments",
    "GL_SGIX_texture_scale_bias",
    "GL_SGIX_framezoom",
    "GL_SGIX_tag_sample_buffer",
    "GL_FfdMaskSGIX",
    "GL_SGIX_polynomial_ffd",
    "GL_SGIX_reference_plane",
    "GL_SGIX_flush_raster",
    "GL_SGIX_depth_texture",
    "GL_SGIS_fog_function",
    "GL_SGIX_fog_offset",
    "GL_HP_image_transform",
    "GL_HP_convolution_border_modes",
    "GL_INGR_palette_buffer",
    "GL_SGIX_texture_add_env",
    "GL_EXT_color_subtable",
    "GL_PGI_vertex_hints",
    "GL_PGI_misc_hints",
    "GL_EXT_paletted_texture",
    "GL_EXT_clip_volume_hint",
    "GL_SGIX_list_priority",
    "GL_SGIX_ir_instrument1",
    "GL_SGIX_calligraphic_fragment",
    "GL_SGIX_texture_lod_bias",
    "GL_SGIX_shadow_ambient",
    "GL_EXT_index_texture",
    "GL_EXT_index_material",
    "GL_EXT_index_func",
    "GL_EXT_index_array_formats",
    "GL_EXT_compiled_vertex_array",
    "GL_EXT_cull_vertex",
    "GL_SGIX_ycrcb",
    "GL_SGIX_fragment_lighting",
    "GL_IBM_rasterpos_clip",
    "GL_HP_texture_lighting",
    "GL_EXT_draw_range_elements",
    "GL_WIN_phong_shading",
    "GL_WIN_specular_fog",
    "GL_EXT_light_texture",
    "GL_SGIX_blend_alpha_minmax",
    "GL_SGIX_impact_pixel_texture",
    "GL_EXT_bgra",
    "GL_SGIX_async",
    "GL_SGIX_async_pixel",
    "GL_SGIX_async_histogram",
    "GL_INTEL_texture_scissor",
    "GL_INTEL_parallel_arrays",
    "GL_HP_occlusion_test",
    "GL_EXT_pixel_transform",
    "GL_EXT_pixel_transform_color_table",
    "GL_EXT_shared_texture_palette",
    "GL_EXT_separate_specular_color",
    "GL_EXT_secondary_color",
    "GL_EXT_texture_perturb_normal",
    "GL_EXT_multi_draw_arrays",
    "GL_EXT_fog_coord",
    "GL_REND_screen_coordinates",
    "GL_EXT_coordinate_frame",
    "GL_EXT_texture_env_combine",
    "GL_APPLE_specular_vector",
    "GL_APPLE_transform_hint",
    "GL_SGIX_fog_scale",
    "GL_SUNX_constant_data",
    "GL_SUN_global_alpha",
    "GL_SUN_triangle_list",
    "GL_SUN_vertex",
    "GL_EXT_blend_func_separate",
    "GL_INGR_color_clamp",
    "GL_INGR_interlace_read",
    "GL_EXT_stencil_wrap",
    "GL_EXT_422_pixels",
    "GL_NV_texgen_reflection",
    "GL_EXT_texture_cube_map",
    "GL_SUN_convolution_border_modes",
    "GL_EXT_texture_env_add",
    "GL_EXT_texture_lod_bias",
    "GL_EXT_texture_filter_anisotropic",
    "GL_EXT_vertex_weighting",
    "GL_NV_light_max_exponent",
    "GL_NV_vertex_array_range",
    "GL_NV_register_combiners",
    "GL_NV_fog_distance",
    "GL_NV_texgen_emboss",
    "GL_NV_blend_square",
    "GL_NV_texture_env_combine4",
    "GL_MESA_resize_buffers",
    "GL_MESA_window_pos",
    "GL_EXT_texture_compression_s3tc",
    "GL_IBM_cull_vertex",
    "GL_IBM_multimode_draw_arrays",
    "GL_IBM_vertex_array_lists",
    "GL_SGIX_subsample",
    "GL_SGIX_ycrcb_subsample",
    "GL_SGIX_ycrcba",
    "GL_SGI_depth_pass_instrument",
    "GL_3DFX_texture_compression_FXT1",
    "GL_3DFX_multisample",
    "GL_3DFX_tbuffer",
    "GL_EXT_multisample",
    "GL_SGIX_vertex_preclip",
    "GL_SGIX_convolution_accuracy",
    "GL_SGIX_resample",
    "GL_SGIS_point_line_texgen",
    "GL_SGIS_texture_color_mask",
    "GL_EXT_texture_env_dot3",
    "GL_ATI_texture_mirror_once",
    "GL_NV_fence",
    "GL_IBM_texture_mirrored_repeat",
    "GL_NV_evaluators",
    "GL_NV_packed_depth_stencil",
    "GL_NV_register_combiners2",
    "GL_NV_texture_compression_vtc",
    "GL_NV_texture_rectangle",
    "GL_NV_texture_shader",
    "GL_NV_texture_shader2",
    "GL_NV_vertex_array_range2",
    "GL_NV_vertex_program",
    "GL_SGIX_texture_coordinate_clamp",
    "GL_SGIX_scalebias_hint",
    "GL_OML_interlace",
    "GL_OML_subsample",
    "GL_OML_resample",
    "GL_NV_copy_depth_to_color",
    "GL_ATI_envmap_bumpmap",
    "GL_ATI_fragment_shader",
    "GL_ATI_pn_triangles",
    "GL_ATI_vertex_array_object",
    "GL_EXT_vertex_shader",
    "GL_ATI_vertex_streams",
    "GL_ATI_element_array",
    "GL_SUN_mesh_array",
    "GL_SUN_slice_accum",
    "GL_NV_multisample_filter_hint",
    "GL_NV_depth_clamp",
    "GL_NV_occlusion_query",
    "GL_NV_point_sprite",
    "GL_NV_texture_shader3",
    "GL_NV_vertex_program1_1",
    "GL_EXT_shadow_funcs",
    "GL_EXT_stencil_two_side",
    "GL_ATI_text_fragment_shader",
    "GL_APPLE_client_storage",
    "GL_APPLE_element_array",
    "GL_APPLE_fence",
    "GL_APPLE_vertex_array_object",
    "GL_APPLE_vertex_array_range",
    "GL_APPLE_ycbcr_422",
    "GL_S3_s3tc",
    "GL_ATI_draw_buffers",
    "GL_ATI_pixel_format_float",
    "GL_ATI_texture_env_combine3",
    "GL_ATI_texture_float",
    "GL_NV_float_buffer",
    "GL_NV_fragment_program",
    "GL_NV_half_float",
    "GL_NV_pixel_data_range",
    "GL_NV_primitive_restart",
    "GL_NV_texture_expand_normal",
    "GL_NV_vertex_program2",
    "GL_ATI_map_object_buffer",
    "GL_ATI_separate_stencil",
    "GL_ATI_vertex_attrib_array_object",
    "GL_OES_read_format",
    "GL_EXT_depth_bounds_test",
    "GL_EXT_texture_mirror_clamp",
    "GL_EXT_blend_equation_separate",
    "GL_MESA_pack_invert",
    "GL_MESA_ycbcr_texture",
    "GL_EXT_pixel_buffer_object",
    "GL_NV_fragment_program_option",
    "GL_NV_fragment_program2",
    "GL_NV_vertex_program2_option",
    "GL_NV_vertex_program3",
    "GL_EXT_framebuffer_object",
    "GL_GREMEDY_string_marker",
    "GL_EXT_packed_depth_stencil",
    "GL_EXT_stencil_clear_tag",
    "GL_EXT_texture_sRGB",
    "GL_EXT_framebuffer_blit",
    "GL_EXT_framebuffer_multisample",
    "GL_MESAX_texture_stack",
    "GL_EXT_timer_query",
    "GL_EXT_gpu_program_parameters",
    "GL_APPLE_flush_buffer_range",
    "GL_EXT_gpu_shader4",
    "GL_EXT_draw_instanced",
    "GL_EXT_packed_float",
    "GL_EXT_texture_array",
    "GL_EXT_texture_buffer_object",
    "GL_EXT_texture_compression_latc",
    "GL_EXT_texture_compression_rgtc",
    "GL_EXT_texture_shared_exponent",
    "GL_NV_depth_buffer_float",
    "GL_NV_framebuffer_multisample_coverage",
    "GL_EXT_framebuffer_sRGB",
    "GL_NV_geometry_shader4",
    "GL_NV_parameter_buffer_object",
    "GL_EXT_draw_buffers2",
    "GL_NV_transform_feedback",
    "GL_EXT_bindable_uniform",
    "GL_EXT_texture_integer",
    "GL_GREMEDY_frame_terminator",
    "GL_NV_conditional_render",
    "GL_NV_present_video",
    "GL_EXT_transform_feedback",
    "GL_EXT_direct_state_access",
    "GL_EXT_vertex_array_bgra",
    "GL_EXT_texture_swizzle",
    "GL_NV_explicit_multisample",
    "GL_NV_transform_feedback2",
    "GL_SGIX_texture_select",
    "GL_INGR_blend_func_separate",
    "GL_SGIX_depth_pass_instrument",
    "GL_SGIX_igloo_interface",
    "GL_EXT_fragment_lighting",
    "GL_EXT_geometry_shader4",
    "GL_EXT_scene_marker",
    "GL_EXT_texture_compression_dxt1",
    "GL_EXT_texture_env",
    "GL_IBM_static_data",
    "GL_NV_gpu_program4",
    "GL_OES_byte_coordinates",
    "GL_OES_compressed_paletted_texture",
    "GL_OES_single_precision",
    "GL_SGIX_pixel_texture_bits",
    "GL_SGIX_texture_range"
};
int __GLeeGLNumExtensions=322;

/* GL_VERSION_1_2 */

#ifdef __GLEE_GL_VERSION_1_2
#ifndef GLEE_C_DEFINED_glBlendColor
#define GLEE_C_DEFINED_glBlendColor
  void __stdcall GLee_Lazy_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)  {if (GLeeInit()) glBlendColor(red, green, blue, alpha);}
  GLEEPFNGLBLENDCOLORPROC GLeeFuncPtr_glBlendColor=GLee_Lazy_glBlendColor;
#endif
#ifndef GLEE_C_DEFINED_glBlendEquation
#define GLEE_C_DEFINED_glBlendEquation
  void __stdcall GLee_Lazy_glBlendEquation(GLenum mode)  {if (GLeeInit()) glBlendEquation(mode);}
  GLEEPFNGLBLENDEQUATIONPROC GLeeFuncPtr_glBlendEquation=GLee_Lazy_glBlendEquation;
#endif
#ifndef GLEE_C_DEFINED_glDrawRangeElements
#define GLEE_C_DEFINED_glDrawRangeElements
  void __stdcall GLee_Lazy_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)  {if (GLeeInit()) glDrawRangeElements(mode, start, end, count, type, indices);}
  GLEEPFNGLDRAWRANGEELEMENTSPROC GLeeFuncPtr_glDrawRangeElements=GLee_Lazy_glDrawRangeElements;
#endif
#ifndef GLEE_C_DEFINED_glColorTable
#define GLEE_C_DEFINED_glColorTable
  void __stdcall GLee_Lazy_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)  {if (GLeeInit()) glColorTable(target, internalformat, width, format, type, table);}
  GLEEPFNGLCOLORTABLEPROC GLeeFuncPtr_glColorTable=GLee_Lazy_glColorTable;
#endif
#ifndef GLEE_C_DEFINED_glColorTableParameterfv
#define GLEE_C_DEFINED_glColorTableParameterfv
  void __stdcall GLee_Lazy_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glColorTableParameterfv(target, pname, params);}
  GLEEPFNGLCOLORTABLEPARAMETERFVPROC GLeeFuncPtr_glColorTableParameterfv=GLee_Lazy_glColorTableParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glColorTableParameteriv
#define GLEE_C_DEFINED_glColorTableParameteriv
  void __stdcall GLee_Lazy_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glColorTableParameteriv(target, pname, params);}
  GLEEPFNGLCOLORTABLEPARAMETERIVPROC GLeeFuncPtr_glColorTableParameteriv=GLee_Lazy_glColorTableParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glCopyColorTable
#define GLEE_C_DEFINED_glCopyColorTable
  void __stdcall GLee_Lazy_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyColorTable(target, internalformat, x, y, width);}
  GLEEPFNGLCOPYCOLORTABLEPROC GLeeFuncPtr_glCopyColorTable=GLee_Lazy_glCopyColorTable;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTable
#define GLEE_C_DEFINED_glGetColorTable
  void __stdcall GLee_Lazy_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * table)  {if (GLeeInit()) glGetColorTable(target, format, type, table);}
  GLEEPFNGLGETCOLORTABLEPROC GLeeFuncPtr_glGetColorTable=GLee_Lazy_glGetColorTable;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableParameterfv
#define GLEE_C_DEFINED_glGetColorTableParameterfv
  void __stdcall GLee_Lazy_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetColorTableParameterfv(target, pname, params);}
  GLEEPFNGLGETCOLORTABLEPARAMETERFVPROC GLeeFuncPtr_glGetColorTableParameterfv=GLee_Lazy_glGetColorTableParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableParameteriv
#define GLEE_C_DEFINED_glGetColorTableParameteriv
  void __stdcall GLee_Lazy_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetColorTableParameteriv(target, pname, params);}
  GLEEPFNGLGETCOLORTABLEPARAMETERIVPROC GLeeFuncPtr_glGetColorTableParameteriv=GLee_Lazy_glGetColorTableParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glColorSubTable
#define GLEE_C_DEFINED_glColorSubTable
  void __stdcall GLee_Lazy_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)  {if (GLeeInit()) glColorSubTable(target, start, count, format, type, data);}
  GLEEPFNGLCOLORSUBTABLEPROC GLeeFuncPtr_glColorSubTable=GLee_Lazy_glColorSubTable;
#endif
#ifndef GLEE_C_DEFINED_glCopyColorSubTable
#define GLEE_C_DEFINED_glCopyColorSubTable
  void __stdcall GLee_Lazy_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyColorSubTable(target, start, x, y, width);}
  GLEEPFNGLCOPYCOLORSUBTABLEPROC GLeeFuncPtr_glCopyColorSubTable=GLee_Lazy_glCopyColorSubTable;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionFilter1D
#define GLEE_C_DEFINED_glConvolutionFilter1D
  void __stdcall GLee_Lazy_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)  {if (GLeeInit()) glConvolutionFilter1D(target, internalformat, width, format, type, image);}
  GLEEPFNGLCONVOLUTIONFILTER1DPROC GLeeFuncPtr_glConvolutionFilter1D=GLee_Lazy_glConvolutionFilter1D;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionFilter2D
#define GLEE_C_DEFINED_glConvolutionFilter2D
  void __stdcall GLee_Lazy_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)  {if (GLeeInit()) glConvolutionFilter2D(target, internalformat, width, height, format, type, image);}
  GLEEPFNGLCONVOLUTIONFILTER2DPROC GLeeFuncPtr_glConvolutionFilter2D=GLee_Lazy_glConvolutionFilter2D;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameterf
#define GLEE_C_DEFINED_glConvolutionParameterf
  void __stdcall GLee_Lazy_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)  {if (GLeeInit()) glConvolutionParameterf(target, pname, params);}
  GLEEPFNGLCONVOLUTIONPARAMETERFPROC GLeeFuncPtr_glConvolutionParameterf=GLee_Lazy_glConvolutionParameterf;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameterfv
#define GLEE_C_DEFINED_glConvolutionParameterfv
  void __stdcall GLee_Lazy_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glConvolutionParameterfv(target, pname, params);}
  GLEEPFNGLCONVOLUTIONPARAMETERFVPROC GLeeFuncPtr_glConvolutionParameterfv=GLee_Lazy_glConvolutionParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameteri
#define GLEE_C_DEFINED_glConvolutionParameteri
  void __stdcall GLee_Lazy_glConvolutionParameteri(GLenum target, GLenum pname, GLint params)  {if (GLeeInit()) glConvolutionParameteri(target, pname, params);}
  GLEEPFNGLCONVOLUTIONPARAMETERIPROC GLeeFuncPtr_glConvolutionParameteri=GLee_Lazy_glConvolutionParameteri;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameteriv
#define GLEE_C_DEFINED_glConvolutionParameteriv
  void __stdcall GLee_Lazy_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glConvolutionParameteriv(target, pname, params);}
  GLEEPFNGLCONVOLUTIONPARAMETERIVPROC GLeeFuncPtr_glConvolutionParameteriv=GLee_Lazy_glConvolutionParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glCopyConvolutionFilter1D
#define GLEE_C_DEFINED_glCopyConvolutionFilter1D
  void __stdcall GLee_Lazy_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyConvolutionFilter1D(target, internalformat, x, y, width);}
  GLEEPFNGLCOPYCONVOLUTIONFILTER1DPROC GLeeFuncPtr_glCopyConvolutionFilter1D=GLee_Lazy_glCopyConvolutionFilter1D;
#endif
#ifndef GLEE_C_DEFINED_glCopyConvolutionFilter2D
#define GLEE_C_DEFINED_glCopyConvolutionFilter2D
  void __stdcall GLee_Lazy_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)  {if (GLeeInit()) glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);}
  GLEEPFNGLCOPYCONVOLUTIONFILTER2DPROC GLeeFuncPtr_glCopyConvolutionFilter2D=GLee_Lazy_glCopyConvolutionFilter2D;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionFilter
#define GLEE_C_DEFINED_glGetConvolutionFilter
  void __stdcall GLee_Lazy_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid * image)  {if (GLeeInit()) glGetConvolutionFilter(target, format, type, image);}
  GLEEPFNGLGETCONVOLUTIONFILTERPROC GLeeFuncPtr_glGetConvolutionFilter=GLee_Lazy_glGetConvolutionFilter;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionParameterfv
#define GLEE_C_DEFINED_glGetConvolutionParameterfv
  void __stdcall GLee_Lazy_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetConvolutionParameterfv(target, pname, params);}
  GLEEPFNGLGETCONVOLUTIONPARAMETERFVPROC GLeeFuncPtr_glGetConvolutionParameterfv=GLee_Lazy_glGetConvolutionParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionParameteriv
#define GLEE_C_DEFINED_glGetConvolutionParameteriv
  void __stdcall GLee_Lazy_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetConvolutionParameteriv(target, pname, params);}
  GLEEPFNGLGETCONVOLUTIONPARAMETERIVPROC GLeeFuncPtr_glGetConvolutionParameteriv=GLee_Lazy_glGetConvolutionParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glGetSeparableFilter
#define GLEE_C_DEFINED_glGetSeparableFilter
  void __stdcall GLee_Lazy_glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span)  {if (GLeeInit()) glGetSeparableFilter(target, format, type, row, column, span);}
  GLEEPFNGLGETSEPARABLEFILTERPROC GLeeFuncPtr_glGetSeparableFilter=GLee_Lazy_glGetSeparableFilter;
#endif
#ifndef GLEE_C_DEFINED_glSeparableFilter2D
#define GLEE_C_DEFINED_glSeparableFilter2D
  void __stdcall GLee_Lazy_glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column)  {if (GLeeInit()) glSeparableFilter2D(target, internalformat, width, height, format, type, row, column);}
  GLEEPFNGLSEPARABLEFILTER2DPROC GLeeFuncPtr_glSeparableFilter2D=GLee_Lazy_glSeparableFilter2D;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogram
#define GLEE_C_DEFINED_glGetHistogram
  void __stdcall GLee_Lazy_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)  {if (GLeeInit()) glGetHistogram(target, reset, format, type, values);}
  GLEEPFNGLGETHISTOGRAMPROC GLeeFuncPtr_glGetHistogram=GLee_Lazy_glGetHistogram;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogramParameterfv
#define GLEE_C_DEFINED_glGetHistogramParameterfv
  void __stdcall GLee_Lazy_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetHistogramParameterfv(target, pname, params);}
  GLEEPFNGLGETHISTOGRAMPARAMETERFVPROC GLeeFuncPtr_glGetHistogramParameterfv=GLee_Lazy_glGetHistogramParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogramParameteriv
#define GLEE_C_DEFINED_glGetHistogramParameteriv
  void __stdcall GLee_Lazy_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetHistogramParameteriv(target, pname, params);}
  GLEEPFNGLGETHISTOGRAMPARAMETERIVPROC GLeeFuncPtr_glGetHistogramParameteriv=GLee_Lazy_glGetHistogramParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmax
#define GLEE_C_DEFINED_glGetMinmax
  void __stdcall GLee_Lazy_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)  {if (GLeeInit()) glGetMinmax(target, reset, format, type, values);}
  GLEEPFNGLGETMINMAXPROC GLeeFuncPtr_glGetMinmax=GLee_Lazy_glGetMinmax;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmaxParameterfv
#define GLEE_C_DEFINED_glGetMinmaxParameterfv
  void __stdcall GLee_Lazy_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetMinmaxParameterfv(target, pname, params);}
  GLEEPFNGLGETMINMAXPARAMETERFVPROC GLeeFuncPtr_glGetMinmaxParameterfv=GLee_Lazy_glGetMinmaxParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmaxParameteriv
#define GLEE_C_DEFINED_glGetMinmaxParameteriv
  void __stdcall GLee_Lazy_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetMinmaxParameteriv(target, pname, params);}
  GLEEPFNGLGETMINMAXPARAMETERIVPROC GLeeFuncPtr_glGetMinmaxParameteriv=GLee_Lazy_glGetMinmaxParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glHistogram
#define GLEE_C_DEFINED_glHistogram
  void __stdcall GLee_Lazy_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)  {if (GLeeInit()) glHistogram(target, width, internalformat, sink);}
  GLEEPFNGLHISTOGRAMPROC GLeeFuncPtr_glHistogram=GLee_Lazy_glHistogram;
#endif
#ifndef GLEE_C_DEFINED_glMinmax
#define GLEE_C_DEFINED_glMinmax
  void __stdcall GLee_Lazy_glMinmax(GLenum target, GLenum internalformat, GLboolean sink)  {if (GLeeInit()) glMinmax(target, internalformat, sink);}
  GLEEPFNGLMINMAXPROC GLeeFuncPtr_glMinmax=GLee_Lazy_glMinmax;
#endif
#ifndef GLEE_C_DEFINED_glResetHistogram
#define GLEE_C_DEFINED_glResetHistogram
  void __stdcall GLee_Lazy_glResetHistogram(GLenum target)  {if (GLeeInit()) glResetHistogram(target);}
  GLEEPFNGLRESETHISTOGRAMPROC GLeeFuncPtr_glResetHistogram=GLee_Lazy_glResetHistogram;
#endif
#ifndef GLEE_C_DEFINED_glResetMinmax
#define GLEE_C_DEFINED_glResetMinmax
  void __stdcall GLee_Lazy_glResetMinmax(GLenum target)  {if (GLeeInit()) glResetMinmax(target);}
  GLEEPFNGLRESETMINMAXPROC GLeeFuncPtr_glResetMinmax=GLee_Lazy_glResetMinmax;
#endif
#ifndef GLEE_C_DEFINED_glTexImage3D
#define GLEE_C_DEFINED_glTexImage3D
  void __stdcall GLee_Lazy_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);}
  GLEEPFNGLTEXIMAGE3DPROC GLeeFuncPtr_glTexImage3D=GLee_Lazy_glTexImage3D;
#endif
#ifndef GLEE_C_DEFINED_glTexSubImage3D
#define GLEE_C_DEFINED_glTexSubImage3D
  void __stdcall GLee_Lazy_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);}
  GLEEPFNGLTEXSUBIMAGE3DPROC GLeeFuncPtr_glTexSubImage3D=GLee_Lazy_glTexSubImage3D;
#endif
#ifndef GLEE_C_DEFINED_glCopyTexSubImage3D
#define GLEE_C_DEFINED_glCopyTexSubImage3D
  void __stdcall GLee_Lazy_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)  {if (GLeeInit()) glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);}
  GLEEPFNGLCOPYTEXSUBIMAGE3DPROC GLeeFuncPtr_glCopyTexSubImage3D=GLee_Lazy_glCopyTexSubImage3D;
#endif
#endif

/* GL_ARB_imaging */

#ifdef __GLEE_GL_ARB_imaging
#endif

/* GL_VERSION_1_3 */

#ifdef __GLEE_GL_VERSION_1_3
#ifndef GLEE_C_DEFINED_glActiveTexture
#define GLEE_C_DEFINED_glActiveTexture
  void __stdcall GLee_Lazy_glActiveTexture(GLenum texture)  {if (GLeeInit()) glActiveTexture(texture);}
  GLEEPFNGLACTIVETEXTUREPROC GLeeFuncPtr_glActiveTexture=GLee_Lazy_glActiveTexture;
#endif
#ifndef GLEE_C_DEFINED_glClientActiveTexture
#define GLEE_C_DEFINED_glClientActiveTexture
  void __stdcall GLee_Lazy_glClientActiveTexture(GLenum texture)  {if (GLeeInit()) glClientActiveTexture(texture);}
  GLEEPFNGLCLIENTACTIVETEXTUREPROC GLeeFuncPtr_glClientActiveTexture=GLee_Lazy_glClientActiveTexture;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1d
#define GLEE_C_DEFINED_glMultiTexCoord1d
  void __stdcall GLee_Lazy_glMultiTexCoord1d(GLenum target, GLdouble s)  {if (GLeeInit()) glMultiTexCoord1d(target, s);}
  GLEEPFNGLMULTITEXCOORD1DPROC GLeeFuncPtr_glMultiTexCoord1d=GLee_Lazy_glMultiTexCoord1d;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1dv
#define GLEE_C_DEFINED_glMultiTexCoord1dv
  void __stdcall GLee_Lazy_glMultiTexCoord1dv(GLenum target, const GLdouble * v)  {if (GLeeInit()) glMultiTexCoord1dv(target, v);}
  GLEEPFNGLMULTITEXCOORD1DVPROC GLeeFuncPtr_glMultiTexCoord1dv=GLee_Lazy_glMultiTexCoord1dv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1f
#define GLEE_C_DEFINED_glMultiTexCoord1f
  void __stdcall GLee_Lazy_glMultiTexCoord1f(GLenum target, GLfloat s)  {if (GLeeInit()) glMultiTexCoord1f(target, s);}
  GLEEPFNGLMULTITEXCOORD1FPROC GLeeFuncPtr_glMultiTexCoord1f=GLee_Lazy_glMultiTexCoord1f;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1fv
#define GLEE_C_DEFINED_glMultiTexCoord1fv
  void __stdcall GLee_Lazy_glMultiTexCoord1fv(GLenum target, const GLfloat * v)  {if (GLeeInit()) glMultiTexCoord1fv(target, v);}
  GLEEPFNGLMULTITEXCOORD1FVPROC GLeeFuncPtr_glMultiTexCoord1fv=GLee_Lazy_glMultiTexCoord1fv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1i
#define GLEE_C_DEFINED_glMultiTexCoord1i
  void __stdcall GLee_Lazy_glMultiTexCoord1i(GLenum target, GLint s)  {if (GLeeInit()) glMultiTexCoord1i(target, s);}
  GLEEPFNGLMULTITEXCOORD1IPROC GLeeFuncPtr_glMultiTexCoord1i=GLee_Lazy_glMultiTexCoord1i;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1iv
#define GLEE_C_DEFINED_glMultiTexCoord1iv
  void __stdcall GLee_Lazy_glMultiTexCoord1iv(GLenum target, const GLint * v)  {if (GLeeInit()) glMultiTexCoord1iv(target, v);}
  GLEEPFNGLMULTITEXCOORD1IVPROC GLeeFuncPtr_glMultiTexCoord1iv=GLee_Lazy_glMultiTexCoord1iv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1s
#define GLEE_C_DEFINED_glMultiTexCoord1s
  void __stdcall GLee_Lazy_glMultiTexCoord1s(GLenum target, GLshort s)  {if (GLeeInit()) glMultiTexCoord1s(target, s);}
  GLEEPFNGLMULTITEXCOORD1SPROC GLeeFuncPtr_glMultiTexCoord1s=GLee_Lazy_glMultiTexCoord1s;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1sv
#define GLEE_C_DEFINED_glMultiTexCoord1sv
  void __stdcall GLee_Lazy_glMultiTexCoord1sv(GLenum target, const GLshort * v)  {if (GLeeInit()) glMultiTexCoord1sv(target, v);}
  GLEEPFNGLMULTITEXCOORD1SVPROC GLeeFuncPtr_glMultiTexCoord1sv=GLee_Lazy_glMultiTexCoord1sv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2d
#define GLEE_C_DEFINED_glMultiTexCoord2d
  void __stdcall GLee_Lazy_glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)  {if (GLeeInit()) glMultiTexCoord2d(target, s, t);}
  GLEEPFNGLMULTITEXCOORD2DPROC GLeeFuncPtr_glMultiTexCoord2d=GLee_Lazy_glMultiTexCoord2d;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2dv
#define GLEE_C_DEFINED_glMultiTexCoord2dv
  void __stdcall GLee_Lazy_glMultiTexCoord2dv(GLenum target, const GLdouble * v)  {if (GLeeInit()) glMultiTexCoord2dv(target, v);}
  GLEEPFNGLMULTITEXCOORD2DVPROC GLeeFuncPtr_glMultiTexCoord2dv=GLee_Lazy_glMultiTexCoord2dv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2f
#define GLEE_C_DEFINED_glMultiTexCoord2f
  void __stdcall GLee_Lazy_glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)  {if (GLeeInit()) glMultiTexCoord2f(target, s, t);}
  GLEEPFNGLMULTITEXCOORD2FPROC GLeeFuncPtr_glMultiTexCoord2f=GLee_Lazy_glMultiTexCoord2f;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2fv
#define GLEE_C_DEFINED_glMultiTexCoord2fv
  void __stdcall GLee_Lazy_glMultiTexCoord2fv(GLenum target, const GLfloat * v)  {if (GLeeInit()) glMultiTexCoord2fv(target, v);}
  GLEEPFNGLMULTITEXCOORD2FVPROC GLeeFuncPtr_glMultiTexCoord2fv=GLee_Lazy_glMultiTexCoord2fv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2i
#define GLEE_C_DEFINED_glMultiTexCoord2i
  void __stdcall GLee_Lazy_glMultiTexCoord2i(GLenum target, GLint s, GLint t)  {if (GLeeInit()) glMultiTexCoord2i(target, s, t);}
  GLEEPFNGLMULTITEXCOORD2IPROC GLeeFuncPtr_glMultiTexCoord2i=GLee_Lazy_glMultiTexCoord2i;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2iv
#define GLEE_C_DEFINED_glMultiTexCoord2iv
  void __stdcall GLee_Lazy_glMultiTexCoord2iv(GLenum target, const GLint * v)  {if (GLeeInit()) glMultiTexCoord2iv(target, v);}
  GLEEPFNGLMULTITEXCOORD2IVPROC GLeeFuncPtr_glMultiTexCoord2iv=GLee_Lazy_glMultiTexCoord2iv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2s
#define GLEE_C_DEFINED_glMultiTexCoord2s
  void __stdcall GLee_Lazy_glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)  {if (GLeeInit()) glMultiTexCoord2s(target, s, t);}
  GLEEPFNGLMULTITEXCOORD2SPROC GLeeFuncPtr_glMultiTexCoord2s=GLee_Lazy_glMultiTexCoord2s;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2sv
#define GLEE_C_DEFINED_glMultiTexCoord2sv
  void __stdcall GLee_Lazy_glMultiTexCoord2sv(GLenum target, const GLshort * v)  {if (GLeeInit()) glMultiTexCoord2sv(target, v);}
  GLEEPFNGLMULTITEXCOORD2SVPROC GLeeFuncPtr_glMultiTexCoord2sv=GLee_Lazy_glMultiTexCoord2sv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3d
#define GLEE_C_DEFINED_glMultiTexCoord3d
  void __stdcall GLee_Lazy_glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)  {if (GLeeInit()) glMultiTexCoord3d(target, s, t, r);}
  GLEEPFNGLMULTITEXCOORD3DPROC GLeeFuncPtr_glMultiTexCoord3d=GLee_Lazy_glMultiTexCoord3d;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3dv
#define GLEE_C_DEFINED_glMultiTexCoord3dv
  void __stdcall GLee_Lazy_glMultiTexCoord3dv(GLenum target, const GLdouble * v)  {if (GLeeInit()) glMultiTexCoord3dv(target, v);}
  GLEEPFNGLMULTITEXCOORD3DVPROC GLeeFuncPtr_glMultiTexCoord3dv=GLee_Lazy_glMultiTexCoord3dv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3f
#define GLEE_C_DEFINED_glMultiTexCoord3f
  void __stdcall GLee_Lazy_glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)  {if (GLeeInit()) glMultiTexCoord3f(target, s, t, r);}
  GLEEPFNGLMULTITEXCOORD3FPROC GLeeFuncPtr_glMultiTexCoord3f=GLee_Lazy_glMultiTexCoord3f;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3fv
#define GLEE_C_DEFINED_glMultiTexCoord3fv
  void __stdcall GLee_Lazy_glMultiTexCoord3fv(GLenum target, const GLfloat * v)  {if (GLeeInit()) glMultiTexCoord3fv(target, v);}
  GLEEPFNGLMULTITEXCOORD3FVPROC GLeeFuncPtr_glMultiTexCoord3fv=GLee_Lazy_glMultiTexCoord3fv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3i
#define GLEE_C_DEFINED_glMultiTexCoord3i
  void __stdcall GLee_Lazy_glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)  {if (GLeeInit()) glMultiTexCoord3i(target, s, t, r);}
  GLEEPFNGLMULTITEXCOORD3IPROC GLeeFuncPtr_glMultiTexCoord3i=GLee_Lazy_glMultiTexCoord3i;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3iv
#define GLEE_C_DEFINED_glMultiTexCoord3iv
  void __stdcall GLee_Lazy_glMultiTexCoord3iv(GLenum target, const GLint * v)  {if (GLeeInit()) glMultiTexCoord3iv(target, v);}
  GLEEPFNGLMULTITEXCOORD3IVPROC GLeeFuncPtr_glMultiTexCoord3iv=GLee_Lazy_glMultiTexCoord3iv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3s
#define GLEE_C_DEFINED_glMultiTexCoord3s
  void __stdcall GLee_Lazy_glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)  {if (GLeeInit()) glMultiTexCoord3s(target, s, t, r);}
  GLEEPFNGLMULTITEXCOORD3SPROC GLeeFuncPtr_glMultiTexCoord3s=GLee_Lazy_glMultiTexCoord3s;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3sv
#define GLEE_C_DEFINED_glMultiTexCoord3sv
  void __stdcall GLee_Lazy_glMultiTexCoord3sv(GLenum target, const GLshort * v)  {if (GLeeInit()) glMultiTexCoord3sv(target, v);}
  GLEEPFNGLMULTITEXCOORD3SVPROC GLeeFuncPtr_glMultiTexCoord3sv=GLee_Lazy_glMultiTexCoord3sv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4d
#define GLEE_C_DEFINED_glMultiTexCoord4d
  void __stdcall GLee_Lazy_glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)  {if (GLeeInit()) glMultiTexCoord4d(target, s, t, r, q);}
  GLEEPFNGLMULTITEXCOORD4DPROC GLeeFuncPtr_glMultiTexCoord4d=GLee_Lazy_glMultiTexCoord4d;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4dv
#define GLEE_C_DEFINED_glMultiTexCoord4dv
  void __stdcall GLee_Lazy_glMultiTexCoord4dv(GLenum target, const GLdouble * v)  {if (GLeeInit()) glMultiTexCoord4dv(target, v);}
  GLEEPFNGLMULTITEXCOORD4DVPROC GLeeFuncPtr_glMultiTexCoord4dv=GLee_Lazy_glMultiTexCoord4dv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4f
#define GLEE_C_DEFINED_glMultiTexCoord4f
  void __stdcall GLee_Lazy_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)  {if (GLeeInit()) glMultiTexCoord4f(target, s, t, r, q);}
  GLEEPFNGLMULTITEXCOORD4FPROC GLeeFuncPtr_glMultiTexCoord4f=GLee_Lazy_glMultiTexCoord4f;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4fv
#define GLEE_C_DEFINED_glMultiTexCoord4fv
  void __stdcall GLee_Lazy_glMultiTexCoord4fv(GLenum target, const GLfloat * v)  {if (GLeeInit()) glMultiTexCoord4fv(target, v);}
  GLEEPFNGLMULTITEXCOORD4FVPROC GLeeFuncPtr_glMultiTexCoord4fv=GLee_Lazy_glMultiTexCoord4fv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4i
#define GLEE_C_DEFINED_glMultiTexCoord4i
  void __stdcall GLee_Lazy_glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)  {if (GLeeInit()) glMultiTexCoord4i(target, s, t, r, q);}
  GLEEPFNGLMULTITEXCOORD4IPROC GLeeFuncPtr_glMultiTexCoord4i=GLee_Lazy_glMultiTexCoord4i;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4iv
#define GLEE_C_DEFINED_glMultiTexCoord4iv
  void __stdcall GLee_Lazy_glMultiTexCoord4iv(GLenum target, const GLint * v)  {if (GLeeInit()) glMultiTexCoord4iv(target, v);}
  GLEEPFNGLMULTITEXCOORD4IVPROC GLeeFuncPtr_glMultiTexCoord4iv=GLee_Lazy_glMultiTexCoord4iv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4s
#define GLEE_C_DEFINED_glMultiTexCoord4s
  void __stdcall GLee_Lazy_glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)  {if (GLeeInit()) glMultiTexCoord4s(target, s, t, r, q);}
  GLEEPFNGLMULTITEXCOORD4SPROC GLeeFuncPtr_glMultiTexCoord4s=GLee_Lazy_glMultiTexCoord4s;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4sv
#define GLEE_C_DEFINED_glMultiTexCoord4sv
  void __stdcall GLee_Lazy_glMultiTexCoord4sv(GLenum target, const GLshort * v)  {if (GLeeInit()) glMultiTexCoord4sv(target, v);}
  GLEEPFNGLMULTITEXCOORD4SVPROC GLeeFuncPtr_glMultiTexCoord4sv=GLee_Lazy_glMultiTexCoord4sv;
#endif
#ifndef GLEE_C_DEFINED_glLoadTransposeMatrixf
#define GLEE_C_DEFINED_glLoadTransposeMatrixf
  void __stdcall GLee_Lazy_glLoadTransposeMatrixf(const GLfloat * m)  {if (GLeeInit()) glLoadTransposeMatrixf(m);}
  GLEEPFNGLLOADTRANSPOSEMATRIXFPROC GLeeFuncPtr_glLoadTransposeMatrixf=GLee_Lazy_glLoadTransposeMatrixf;
#endif
#ifndef GLEE_C_DEFINED_glLoadTransposeMatrixd
#define GLEE_C_DEFINED_glLoadTransposeMatrixd
  void __stdcall GLee_Lazy_glLoadTransposeMatrixd(const GLdouble * m)  {if (GLeeInit()) glLoadTransposeMatrixd(m);}
  GLEEPFNGLLOADTRANSPOSEMATRIXDPROC GLeeFuncPtr_glLoadTransposeMatrixd=GLee_Lazy_glLoadTransposeMatrixd;
#endif
#ifndef GLEE_C_DEFINED_glMultTransposeMatrixf
#define GLEE_C_DEFINED_glMultTransposeMatrixf
  void __stdcall GLee_Lazy_glMultTransposeMatrixf(const GLfloat * m)  {if (GLeeInit()) glMultTransposeMatrixf(m);}
  GLEEPFNGLMULTTRANSPOSEMATRIXFPROC GLeeFuncPtr_glMultTransposeMatrixf=GLee_Lazy_glMultTransposeMatrixf;
#endif
#ifndef GLEE_C_DEFINED_glMultTransposeMatrixd
#define GLEE_C_DEFINED_glMultTransposeMatrixd
  void __stdcall GLee_Lazy_glMultTransposeMatrixd(const GLdouble * m)  {if (GLeeInit()) glMultTransposeMatrixd(m);}
  GLEEPFNGLMULTTRANSPOSEMATRIXDPROC GLeeFuncPtr_glMultTransposeMatrixd=GLee_Lazy_glMultTransposeMatrixd;
#endif
#ifndef GLEE_C_DEFINED_glSampleCoverage
#define GLEE_C_DEFINED_glSampleCoverage
  void __stdcall GLee_Lazy_glSampleCoverage(GLclampf value, GLboolean invert)  {if (GLeeInit()) glSampleCoverage(value, invert);}
  GLEEPFNGLSAMPLECOVERAGEPROC GLeeFuncPtr_glSampleCoverage=GLee_Lazy_glSampleCoverage;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage3D
#define GLEE_C_DEFINED_glCompressedTexImage3D
  void __stdcall GLee_Lazy_glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data)  {if (GLeeInit()) glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);}
  GLEEPFNGLCOMPRESSEDTEXIMAGE3DPROC GLeeFuncPtr_glCompressedTexImage3D=GLee_Lazy_glCompressedTexImage3D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage2D
#define GLEE_C_DEFINED_glCompressedTexImage2D
  void __stdcall GLee_Lazy_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data)  {if (GLeeInit()) glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);}
  GLEEPFNGLCOMPRESSEDTEXIMAGE2DPROC GLeeFuncPtr_glCompressedTexImage2D=GLee_Lazy_glCompressedTexImage2D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage1D
#define GLEE_C_DEFINED_glCompressedTexImage1D
  void __stdcall GLee_Lazy_glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data)  {if (GLeeInit()) glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);}
  GLEEPFNGLCOMPRESSEDTEXIMAGE1DPROC GLeeFuncPtr_glCompressedTexImage1D=GLee_Lazy_glCompressedTexImage1D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage3D
#define GLEE_C_DEFINED_glCompressedTexSubImage3D
  void __stdcall GLee_Lazy_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data)  {if (GLeeInit()) glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);}
  GLEEPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC GLeeFuncPtr_glCompressedTexSubImage3D=GLee_Lazy_glCompressedTexSubImage3D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage2D
#define GLEE_C_DEFINED_glCompressedTexSubImage2D
  void __stdcall GLee_Lazy_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data)  {if (GLeeInit()) glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);}
  GLEEPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC GLeeFuncPtr_glCompressedTexSubImage2D=GLee_Lazy_glCompressedTexSubImage2D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage1D
#define GLEE_C_DEFINED_glCompressedTexSubImage1D
  void __stdcall GLee_Lazy_glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data)  {if (GLeeInit()) glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);}
  GLEEPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC GLeeFuncPtr_glCompressedTexSubImage1D=GLee_Lazy_glCompressedTexSubImage1D;
#endif
#ifndef GLEE_C_DEFINED_glGetCompressedTexImage
#define GLEE_C_DEFINED_glGetCompressedTexImage
  void __stdcall GLee_Lazy_glGetCompressedTexImage(GLenum target, GLint level, GLvoid * img)  {if (GLeeInit()) glGetCompressedTexImage(target, level, img);}
  GLEEPFNGLGETCOMPRESSEDTEXIMAGEPROC GLeeFuncPtr_glGetCompressedTexImage=GLee_Lazy_glGetCompressedTexImage;
#endif
#endif

/* GL_VERSION_1_4 */

#ifdef __GLEE_GL_VERSION_1_4
#ifndef GLEE_C_DEFINED_glBlendFuncSeparate
#define GLEE_C_DEFINED_glBlendFuncSeparate
  void __stdcall GLee_Lazy_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)  {if (GLeeInit()) glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);}
  GLEEPFNGLBLENDFUNCSEPARATEPROC GLeeFuncPtr_glBlendFuncSeparate=GLee_Lazy_glBlendFuncSeparate;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordf
#define GLEE_C_DEFINED_glFogCoordf
  void __stdcall GLee_Lazy_glFogCoordf(GLfloat coord)  {if (GLeeInit()) glFogCoordf(coord);}
  GLEEPFNGLFOGCOORDFPROC GLeeFuncPtr_glFogCoordf=GLee_Lazy_glFogCoordf;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordfv
#define GLEE_C_DEFINED_glFogCoordfv
  void __stdcall GLee_Lazy_glFogCoordfv(const GLfloat * coord)  {if (GLeeInit()) glFogCoordfv(coord);}
  GLEEPFNGLFOGCOORDFVPROC GLeeFuncPtr_glFogCoordfv=GLee_Lazy_glFogCoordfv;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordd
#define GLEE_C_DEFINED_glFogCoordd
  void __stdcall GLee_Lazy_glFogCoordd(GLdouble coord)  {if (GLeeInit()) glFogCoordd(coord);}
  GLEEPFNGLFOGCOORDDPROC GLeeFuncPtr_glFogCoordd=GLee_Lazy_glFogCoordd;
#endif
#ifndef GLEE_C_DEFINED_glFogCoorddv
#define GLEE_C_DEFINED_glFogCoorddv
  void __stdcall GLee_Lazy_glFogCoorddv(const GLdouble * coord)  {if (GLeeInit()) glFogCoorddv(coord);}
  GLEEPFNGLFOGCOORDDVPROC GLeeFuncPtr_glFogCoorddv=GLee_Lazy_glFogCoorddv;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordPointer
#define GLEE_C_DEFINED_glFogCoordPointer
  void __stdcall GLee_Lazy_glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glFogCoordPointer(type, stride, pointer);}
  GLEEPFNGLFOGCOORDPOINTERPROC GLeeFuncPtr_glFogCoordPointer=GLee_Lazy_glFogCoordPointer;
#endif
#ifndef GLEE_C_DEFINED_glMultiDrawArrays
#define GLEE_C_DEFINED_glMultiDrawArrays
  void __stdcall GLee_Lazy_glMultiDrawArrays(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount)  {if (GLeeInit()) glMultiDrawArrays(mode, first, count, primcount);}
  GLEEPFNGLMULTIDRAWARRAYSPROC GLeeFuncPtr_glMultiDrawArrays=GLee_Lazy_glMultiDrawArrays;
#endif
#ifndef GLEE_C_DEFINED_glMultiDrawElements
#define GLEE_C_DEFINED_glMultiDrawElements
  void __stdcall GLee_Lazy_glMultiDrawElements(GLenum mode, const GLsizei * count, GLenum type, const GLvoid* * indices, GLsizei primcount)  {if (GLeeInit()) glMultiDrawElements(mode, count, type, indices, primcount);}
  GLEEPFNGLMULTIDRAWELEMENTSPROC GLeeFuncPtr_glMultiDrawElements=GLee_Lazy_glMultiDrawElements;
#endif
#ifndef GLEE_C_DEFINED_glPointParameterf
#define GLEE_C_DEFINED_glPointParameterf
  void __stdcall GLee_Lazy_glPointParameterf(GLenum pname, GLfloat param)  {if (GLeeInit()) glPointParameterf(pname, param);}
  GLEEPFNGLPOINTPARAMETERFPROC GLeeFuncPtr_glPointParameterf=GLee_Lazy_glPointParameterf;
#endif
#ifndef GLEE_C_DEFINED_glPointParameterfv
#define GLEE_C_DEFINED_glPointParameterfv
  void __stdcall GLee_Lazy_glPointParameterfv(GLenum pname, const GLfloat * params)  {if (GLeeInit()) glPointParameterfv(pname, params);}
  GLEEPFNGLPOINTPARAMETERFVPROC GLeeFuncPtr_glPointParameterfv=GLee_Lazy_glPointParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glPointParameteri
#define GLEE_C_DEFINED_glPointParameteri
  void __stdcall GLee_Lazy_glPointParameteri(GLenum pname, GLint param)  {if (GLeeInit()) glPointParameteri(pname, param);}
  GLEEPFNGLPOINTPARAMETERIPROC GLeeFuncPtr_glPointParameteri=GLee_Lazy_glPointParameteri;
#endif
#ifndef GLEE_C_DEFINED_glPointParameteriv
#define GLEE_C_DEFINED_glPointParameteriv
  void __stdcall GLee_Lazy_glPointParameteriv(GLenum pname, const GLint * params)  {if (GLeeInit()) glPointParameteriv(pname, params);}
  GLEEPFNGLPOINTPARAMETERIVPROC GLeeFuncPtr_glPointParameteriv=GLee_Lazy_glPointParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3b
#define GLEE_C_DEFINED_glSecondaryColor3b
  void __stdcall GLee_Lazy_glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)  {if (GLeeInit()) glSecondaryColor3b(red, green, blue);}
  GLEEPFNGLSECONDARYCOLOR3BPROC GLeeFuncPtr_glSecondaryColor3b=GLee_Lazy_glSecondaryColor3b;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3bv
#define GLEE_C_DEFINED_glSecondaryColor3bv
  void __stdcall GLee_Lazy_glSecondaryColor3bv(const GLbyte * v)  {if (GLeeInit()) glSecondaryColor3bv(v);}
  GLEEPFNGLSECONDARYCOLOR3BVPROC GLeeFuncPtr_glSecondaryColor3bv=GLee_Lazy_glSecondaryColor3bv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3d
#define GLEE_C_DEFINED_glSecondaryColor3d
  void __stdcall GLee_Lazy_glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)  {if (GLeeInit()) glSecondaryColor3d(red, green, blue);}
  GLEEPFNGLSECONDARYCOLOR3DPROC GLeeFuncPtr_glSecondaryColor3d=GLee_Lazy_glSecondaryColor3d;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3dv
#define GLEE_C_DEFINED_glSecondaryColor3dv
  void __stdcall GLee_Lazy_glSecondaryColor3dv(const GLdouble * v)  {if (GLeeInit()) glSecondaryColor3dv(v);}
  GLEEPFNGLSECONDARYCOLOR3DVPROC GLeeFuncPtr_glSecondaryColor3dv=GLee_Lazy_glSecondaryColor3dv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3f
#define GLEE_C_DEFINED_glSecondaryColor3f
  void __stdcall GLee_Lazy_glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)  {if (GLeeInit()) glSecondaryColor3f(red, green, blue);}
  GLEEPFNGLSECONDARYCOLOR3FPROC GLeeFuncPtr_glSecondaryColor3f=GLee_Lazy_glSecondaryColor3f;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3fv
#define GLEE_C_DEFINED_glSecondaryColor3fv
  void __stdcall GLee_Lazy_glSecondaryColor3fv(const GLfloat * v)  {if (GLeeInit()) glSecondaryColor3fv(v);}
  GLEEPFNGLSECONDARYCOLOR3FVPROC GLeeFuncPtr_glSecondaryColor3fv=GLee_Lazy_glSecondaryColor3fv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3i
#define GLEE_C_DEFINED_glSecondaryColor3i
  void __stdcall GLee_Lazy_glSecondaryColor3i(GLint red, GLint green, GLint blue)  {if (GLeeInit()) glSecondaryColor3i(red, green, blue);}
  GLEEPFNGLSECONDARYCOLOR3IPROC GLeeFuncPtr_glSecondaryColor3i=GLee_Lazy_glSecondaryColor3i;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3iv
#define GLEE_C_DEFINED_glSecondaryColor3iv
  void __stdcall GLee_Lazy_glSecondaryColor3iv(const GLint * v)  {if (GLeeInit()) glSecondaryColor3iv(v);}
  GLEEPFNGLSECONDARYCOLOR3IVPROC GLeeFuncPtr_glSecondaryColor3iv=GLee_Lazy_glSecondaryColor3iv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3s
#define GLEE_C_DEFINED_glSecondaryColor3s
  void __stdcall GLee_Lazy_glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)  {if (GLeeInit()) glSecondaryColor3s(red, green, blue);}
  GLEEPFNGLSECONDARYCOLOR3SPROC GLeeFuncPtr_glSecondaryColor3s=GLee_Lazy_glSecondaryColor3s;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3sv
#define GLEE_C_DEFINED_glSecondaryColor3sv
  void __stdcall GLee_Lazy_glSecondaryColor3sv(const GLshort * v)  {if (GLeeInit()) glSecondaryColor3sv(v);}
  GLEEPFNGLSECONDARYCOLOR3SVPROC GLeeFuncPtr_glSecondaryColor3sv=GLee_Lazy_glSecondaryColor3sv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3ub
#define GLEE_C_DEFINED_glSecondaryColor3ub
  void __stdcall GLee_Lazy_glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)  {if (GLeeInit()) glSecondaryColor3ub(red, green, blue);}
  GLEEPFNGLSECONDARYCOLOR3UBPROC GLeeFuncPtr_glSecondaryColor3ub=GLee_Lazy_glSecondaryColor3ub;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3ubv
#define GLEE_C_DEFINED_glSecondaryColor3ubv
  void __stdcall GLee_Lazy_glSecondaryColor3ubv(const GLubyte * v)  {if (GLeeInit()) glSecondaryColor3ubv(v);}
  GLEEPFNGLSECONDARYCOLOR3UBVPROC GLeeFuncPtr_glSecondaryColor3ubv=GLee_Lazy_glSecondaryColor3ubv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3ui
#define GLEE_C_DEFINED_glSecondaryColor3ui
  void __stdcall GLee_Lazy_glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)  {if (GLeeInit()) glSecondaryColor3ui(red, green, blue);}
  GLEEPFNGLSECONDARYCOLOR3UIPROC GLeeFuncPtr_glSecondaryColor3ui=GLee_Lazy_glSecondaryColor3ui;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3uiv
#define GLEE_C_DEFINED_glSecondaryColor3uiv
  void __stdcall GLee_Lazy_glSecondaryColor3uiv(const GLuint * v)  {if (GLeeInit()) glSecondaryColor3uiv(v);}
  GLEEPFNGLSECONDARYCOLOR3UIVPROC GLeeFuncPtr_glSecondaryColor3uiv=GLee_Lazy_glSecondaryColor3uiv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3us
#define GLEE_C_DEFINED_glSecondaryColor3us
  void __stdcall GLee_Lazy_glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)  {if (GLeeInit()) glSecondaryColor3us(red, green, blue);}
  GLEEPFNGLSECONDARYCOLOR3USPROC GLeeFuncPtr_glSecondaryColor3us=GLee_Lazy_glSecondaryColor3us;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3usv
#define GLEE_C_DEFINED_glSecondaryColor3usv
  void __stdcall GLee_Lazy_glSecondaryColor3usv(const GLushort * v)  {if (GLeeInit()) glSecondaryColor3usv(v);}
  GLEEPFNGLSECONDARYCOLOR3USVPROC GLeeFuncPtr_glSecondaryColor3usv=GLee_Lazy_glSecondaryColor3usv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColorPointer
#define GLEE_C_DEFINED_glSecondaryColorPointer
  void __stdcall GLee_Lazy_glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glSecondaryColorPointer(size, type, stride, pointer);}
  GLEEPFNGLSECONDARYCOLORPOINTERPROC GLeeFuncPtr_glSecondaryColorPointer=GLee_Lazy_glSecondaryColorPointer;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2d
#define GLEE_C_DEFINED_glWindowPos2d
  void __stdcall GLee_Lazy_glWindowPos2d(GLdouble x, GLdouble y)  {if (GLeeInit()) glWindowPos2d(x, y);}
  GLEEPFNGLWINDOWPOS2DPROC GLeeFuncPtr_glWindowPos2d=GLee_Lazy_glWindowPos2d;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2dv
#define GLEE_C_DEFINED_glWindowPos2dv
  void __stdcall GLee_Lazy_glWindowPos2dv(const GLdouble * v)  {if (GLeeInit()) glWindowPos2dv(v);}
  GLEEPFNGLWINDOWPOS2DVPROC GLeeFuncPtr_glWindowPos2dv=GLee_Lazy_glWindowPos2dv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2f
#define GLEE_C_DEFINED_glWindowPos2f
  void __stdcall GLee_Lazy_glWindowPos2f(GLfloat x, GLfloat y)  {if (GLeeInit()) glWindowPos2f(x, y);}
  GLEEPFNGLWINDOWPOS2FPROC GLeeFuncPtr_glWindowPos2f=GLee_Lazy_glWindowPos2f;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2fv
#define GLEE_C_DEFINED_glWindowPos2fv
  void __stdcall GLee_Lazy_glWindowPos2fv(const GLfloat * v)  {if (GLeeInit()) glWindowPos2fv(v);}
  GLEEPFNGLWINDOWPOS2FVPROC GLeeFuncPtr_glWindowPos2fv=GLee_Lazy_glWindowPos2fv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2i
#define GLEE_C_DEFINED_glWindowPos2i
  void __stdcall GLee_Lazy_glWindowPos2i(GLint x, GLint y)  {if (GLeeInit()) glWindowPos2i(x, y);}
  GLEEPFNGLWINDOWPOS2IPROC GLeeFuncPtr_glWindowPos2i=GLee_Lazy_glWindowPos2i;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2iv
#define GLEE_C_DEFINED_glWindowPos2iv
  void __stdcall GLee_Lazy_glWindowPos2iv(const GLint * v)  {if (GLeeInit()) glWindowPos2iv(v);}
  GLEEPFNGLWINDOWPOS2IVPROC GLeeFuncPtr_glWindowPos2iv=GLee_Lazy_glWindowPos2iv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2s
#define GLEE_C_DEFINED_glWindowPos2s
  void __stdcall GLee_Lazy_glWindowPos2s(GLshort x, GLshort y)  {if (GLeeInit()) glWindowPos2s(x, y);}
  GLEEPFNGLWINDOWPOS2SPROC GLeeFuncPtr_glWindowPos2s=GLee_Lazy_glWindowPos2s;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2sv
#define GLEE_C_DEFINED_glWindowPos2sv
  void __stdcall GLee_Lazy_glWindowPos2sv(const GLshort * v)  {if (GLeeInit()) glWindowPos2sv(v);}
  GLEEPFNGLWINDOWPOS2SVPROC GLeeFuncPtr_glWindowPos2sv=GLee_Lazy_glWindowPos2sv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3d
#define GLEE_C_DEFINED_glWindowPos3d
  void __stdcall GLee_Lazy_glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)  {if (GLeeInit()) glWindowPos3d(x, y, z);}
  GLEEPFNGLWINDOWPOS3DPROC GLeeFuncPtr_glWindowPos3d=GLee_Lazy_glWindowPos3d;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3dv
#define GLEE_C_DEFINED_glWindowPos3dv
  void __stdcall GLee_Lazy_glWindowPos3dv(const GLdouble * v)  {if (GLeeInit()) glWindowPos3dv(v);}
  GLEEPFNGLWINDOWPOS3DVPROC GLeeFuncPtr_glWindowPos3dv=GLee_Lazy_glWindowPos3dv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3f
#define GLEE_C_DEFINED_glWindowPos3f
  void __stdcall GLee_Lazy_glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glWindowPos3f(x, y, z);}
  GLEEPFNGLWINDOWPOS3FPROC GLeeFuncPtr_glWindowPos3f=GLee_Lazy_glWindowPos3f;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3fv
#define GLEE_C_DEFINED_glWindowPos3fv
  void __stdcall GLee_Lazy_glWindowPos3fv(const GLfloat * v)  {if (GLeeInit()) glWindowPos3fv(v);}
  GLEEPFNGLWINDOWPOS3FVPROC GLeeFuncPtr_glWindowPos3fv=GLee_Lazy_glWindowPos3fv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3i
#define GLEE_C_DEFINED_glWindowPos3i
  void __stdcall GLee_Lazy_glWindowPos3i(GLint x, GLint y, GLint z)  {if (GLeeInit()) glWindowPos3i(x, y, z);}
  GLEEPFNGLWINDOWPOS3IPROC GLeeFuncPtr_glWindowPos3i=GLee_Lazy_glWindowPos3i;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3iv
#define GLEE_C_DEFINED_glWindowPos3iv
  void __stdcall GLee_Lazy_glWindowPos3iv(const GLint * v)  {if (GLeeInit()) glWindowPos3iv(v);}
  GLEEPFNGLWINDOWPOS3IVPROC GLeeFuncPtr_glWindowPos3iv=GLee_Lazy_glWindowPos3iv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3s
#define GLEE_C_DEFINED_glWindowPos3s
  void __stdcall GLee_Lazy_glWindowPos3s(GLshort x, GLshort y, GLshort z)  {if (GLeeInit()) glWindowPos3s(x, y, z);}
  GLEEPFNGLWINDOWPOS3SPROC GLeeFuncPtr_glWindowPos3s=GLee_Lazy_glWindowPos3s;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3sv
#define GLEE_C_DEFINED_glWindowPos3sv
  void __stdcall GLee_Lazy_glWindowPos3sv(const GLshort * v)  {if (GLeeInit()) glWindowPos3sv(v);}
  GLEEPFNGLWINDOWPOS3SVPROC GLeeFuncPtr_glWindowPos3sv=GLee_Lazy_glWindowPos3sv;
#endif
#endif

/* GL_VERSION_1_5 */

#ifdef __GLEE_GL_VERSION_1_5
#ifndef GLEE_C_DEFINED_glGenQueries
#define GLEE_C_DEFINED_glGenQueries
  void __stdcall GLee_Lazy_glGenQueries(GLsizei n, GLuint * ids)  {if (GLeeInit()) glGenQueries(n, ids);}
  GLEEPFNGLGENQUERIESPROC GLeeFuncPtr_glGenQueries=GLee_Lazy_glGenQueries;
#endif
#ifndef GLEE_C_DEFINED_glDeleteQueries
#define GLEE_C_DEFINED_glDeleteQueries
  void __stdcall GLee_Lazy_glDeleteQueries(GLsizei n, const GLuint * ids)  {if (GLeeInit()) glDeleteQueries(n, ids);}
  GLEEPFNGLDELETEQUERIESPROC GLeeFuncPtr_glDeleteQueries=GLee_Lazy_glDeleteQueries;
#endif
#ifndef GLEE_C_DEFINED_glIsQuery
#define GLEE_C_DEFINED_glIsQuery
  GLboolean __stdcall GLee_Lazy_glIsQuery(GLuint id)  {if (GLeeInit()) return glIsQuery(id); return (GLboolean)0;}
  GLEEPFNGLISQUERYPROC GLeeFuncPtr_glIsQuery=GLee_Lazy_glIsQuery;
#endif
#ifndef GLEE_C_DEFINED_glBeginQuery
#define GLEE_C_DEFINED_glBeginQuery
  void __stdcall GLee_Lazy_glBeginQuery(GLenum target, GLuint id)  {if (GLeeInit()) glBeginQuery(target, id);}
  GLEEPFNGLBEGINQUERYPROC GLeeFuncPtr_glBeginQuery=GLee_Lazy_glBeginQuery;
#endif
#ifndef GLEE_C_DEFINED_glEndQuery
#define GLEE_C_DEFINED_glEndQuery
  void __stdcall GLee_Lazy_glEndQuery(GLenum target)  {if (GLeeInit()) glEndQuery(target);}
  GLEEPFNGLENDQUERYPROC GLeeFuncPtr_glEndQuery=GLee_Lazy_glEndQuery;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryiv
#define GLEE_C_DEFINED_glGetQueryiv
  void __stdcall GLee_Lazy_glGetQueryiv(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetQueryiv(target, pname, params);}
  GLEEPFNGLGETQUERYIVPROC GLeeFuncPtr_glGetQueryiv=GLee_Lazy_glGetQueryiv;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryObjectiv
#define GLEE_C_DEFINED_glGetQueryObjectiv
  void __stdcall GLee_Lazy_glGetQueryObjectiv(GLuint id, GLenum pname, GLint * params)  {if (GLeeInit()) glGetQueryObjectiv(id, pname, params);}
  GLEEPFNGLGETQUERYOBJECTIVPROC GLeeFuncPtr_glGetQueryObjectiv=GLee_Lazy_glGetQueryObjectiv;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryObjectuiv
#define GLEE_C_DEFINED_glGetQueryObjectuiv
  void __stdcall GLee_Lazy_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint * params)  {if (GLeeInit()) glGetQueryObjectuiv(id, pname, params);}
  GLEEPFNGLGETQUERYOBJECTUIVPROC GLeeFuncPtr_glGetQueryObjectuiv=GLee_Lazy_glGetQueryObjectuiv;
#endif
#ifndef GLEE_C_DEFINED_glBindBuffer
#define GLEE_C_DEFINED_glBindBuffer
  void __stdcall GLee_Lazy_glBindBuffer(GLenum target, GLuint buffer)  {if (GLeeInit()) glBindBuffer(target, buffer);}
  GLEEPFNGLBINDBUFFERPROC GLeeFuncPtr_glBindBuffer=GLee_Lazy_glBindBuffer;
#endif
#ifndef GLEE_C_DEFINED_glDeleteBuffers
#define GLEE_C_DEFINED_glDeleteBuffers
  void __stdcall GLee_Lazy_glDeleteBuffers(GLsizei n, const GLuint * buffers)  {if (GLeeInit()) glDeleteBuffers(n, buffers);}
  GLEEPFNGLDELETEBUFFERSPROC GLeeFuncPtr_glDeleteBuffers=GLee_Lazy_glDeleteBuffers;
#endif
#ifndef GLEE_C_DEFINED_glGenBuffers
#define GLEE_C_DEFINED_glGenBuffers
  void __stdcall GLee_Lazy_glGenBuffers(GLsizei n, GLuint * buffers)  {if (GLeeInit()) glGenBuffers(n, buffers);}
  GLEEPFNGLGENBUFFERSPROC GLeeFuncPtr_glGenBuffers=GLee_Lazy_glGenBuffers;
#endif
#ifndef GLEE_C_DEFINED_glIsBuffer
#define GLEE_C_DEFINED_glIsBuffer
  GLboolean __stdcall GLee_Lazy_glIsBuffer(GLuint buffer)  {if (GLeeInit()) return glIsBuffer(buffer); return (GLboolean)0;}
  GLEEPFNGLISBUFFERPROC GLeeFuncPtr_glIsBuffer=GLee_Lazy_glIsBuffer;
#endif
#ifndef GLEE_C_DEFINED_glBufferData
#define GLEE_C_DEFINED_glBufferData
  void __stdcall GLee_Lazy_glBufferData(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage)  {if (GLeeInit()) glBufferData(target, size, data, usage);}
  GLEEPFNGLBUFFERDATAPROC GLeeFuncPtr_glBufferData=GLee_Lazy_glBufferData;
#endif
#ifndef GLEE_C_DEFINED_glBufferSubData
#define GLEE_C_DEFINED_glBufferSubData
  void __stdcall GLee_Lazy_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data)  {if (GLeeInit()) glBufferSubData(target, offset, size, data);}
  GLEEPFNGLBUFFERSUBDATAPROC GLeeFuncPtr_glBufferSubData=GLee_Lazy_glBufferSubData;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferSubData
#define GLEE_C_DEFINED_glGetBufferSubData
  void __stdcall GLee_Lazy_glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data)  {if (GLeeInit()) glGetBufferSubData(target, offset, size, data);}
  GLEEPFNGLGETBUFFERSUBDATAPROC GLeeFuncPtr_glGetBufferSubData=GLee_Lazy_glGetBufferSubData;
#endif
#ifndef GLEE_C_DEFINED_glMapBuffer
#define GLEE_C_DEFINED_glMapBuffer
  GLvoid* __stdcall GLee_Lazy_glMapBuffer(GLenum target, GLenum access)  {if (GLeeInit()) return glMapBuffer(target, access); return (GLvoid*)0;}
  GLEEPFNGLMAPBUFFERPROC GLeeFuncPtr_glMapBuffer=GLee_Lazy_glMapBuffer;
#endif
#ifndef GLEE_C_DEFINED_glUnmapBuffer
#define GLEE_C_DEFINED_glUnmapBuffer
  GLboolean __stdcall GLee_Lazy_glUnmapBuffer(GLenum target)  {if (GLeeInit()) return glUnmapBuffer(target); return (GLboolean)0;}
  GLEEPFNGLUNMAPBUFFERPROC GLeeFuncPtr_glUnmapBuffer=GLee_Lazy_glUnmapBuffer;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferParameteriv
#define GLEE_C_DEFINED_glGetBufferParameteriv
  void __stdcall GLee_Lazy_glGetBufferParameteriv(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetBufferParameteriv(target, pname, params);}
  GLEEPFNGLGETBUFFERPARAMETERIVPROC GLeeFuncPtr_glGetBufferParameteriv=GLee_Lazy_glGetBufferParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferPointerv
#define GLEE_C_DEFINED_glGetBufferPointerv
  void __stdcall GLee_Lazy_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* * params)  {if (GLeeInit()) glGetBufferPointerv(target, pname, params);}
  GLEEPFNGLGETBUFFERPOINTERVPROC GLeeFuncPtr_glGetBufferPointerv=GLee_Lazy_glGetBufferPointerv;
#endif
#endif

/* GL_VERSION_2_0 */

#ifdef __GLEE_GL_VERSION_2_0
#ifndef GLEE_C_DEFINED_glBlendEquationSeparate
#define GLEE_C_DEFINED_glBlendEquationSeparate
  void __stdcall GLee_Lazy_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)  {if (GLeeInit()) glBlendEquationSeparate(modeRGB, modeAlpha);}
  GLEEPFNGLBLENDEQUATIONSEPARATEPROC GLeeFuncPtr_glBlendEquationSeparate=GLee_Lazy_glBlendEquationSeparate;
#endif
#ifndef GLEE_C_DEFINED_glDrawBuffers
#define GLEE_C_DEFINED_glDrawBuffers
  void __stdcall GLee_Lazy_glDrawBuffers(GLsizei n, const GLenum * bufs)  {if (GLeeInit()) glDrawBuffers(n, bufs);}
  GLEEPFNGLDRAWBUFFERSPROC GLeeFuncPtr_glDrawBuffers=GLee_Lazy_glDrawBuffers;
#endif
#ifndef GLEE_C_DEFINED_glStencilOpSeparate
#define GLEE_C_DEFINED_glStencilOpSeparate
  void __stdcall GLee_Lazy_glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)  {if (GLeeInit()) glStencilOpSeparate(face, sfail, dpfail, dppass);}
  GLEEPFNGLSTENCILOPSEPARATEPROC GLeeFuncPtr_glStencilOpSeparate=GLee_Lazy_glStencilOpSeparate;
#endif
#ifndef GLEE_C_DEFINED_glStencilFuncSeparate
#define GLEE_C_DEFINED_glStencilFuncSeparate
  void __stdcall GLee_Lazy_glStencilFuncSeparate(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)  {if (GLeeInit()) glStencilFuncSeparate(frontfunc, backfunc, ref, mask);}
  GLEEPFNGLSTENCILFUNCSEPARATEPROC GLeeFuncPtr_glStencilFuncSeparate=GLee_Lazy_glStencilFuncSeparate;
#endif
#ifndef GLEE_C_DEFINED_glStencilMaskSeparate
#define GLEE_C_DEFINED_glStencilMaskSeparate
  void __stdcall GLee_Lazy_glStencilMaskSeparate(GLenum face, GLuint mask)  {if (GLeeInit()) glStencilMaskSeparate(face, mask);}
  GLEEPFNGLSTENCILMASKSEPARATEPROC GLeeFuncPtr_glStencilMaskSeparate=GLee_Lazy_glStencilMaskSeparate;
#endif
#ifndef GLEE_C_DEFINED_glAttachShader
#define GLEE_C_DEFINED_glAttachShader
  void __stdcall GLee_Lazy_glAttachShader(GLuint program, GLuint shader)  {if (GLeeInit()) glAttachShader(program, shader);}
  GLEEPFNGLATTACHSHADERPROC GLeeFuncPtr_glAttachShader=GLee_Lazy_glAttachShader;
#endif
#ifndef GLEE_C_DEFINED_glBindAttribLocation
#define GLEE_C_DEFINED_glBindAttribLocation
  void __stdcall GLee_Lazy_glBindAttribLocation(GLuint program, GLuint index, const GLchar * name)  {if (GLeeInit()) glBindAttribLocation(program, index, name);}
  GLEEPFNGLBINDATTRIBLOCATIONPROC GLeeFuncPtr_glBindAttribLocation=GLee_Lazy_glBindAttribLocation;
#endif
#ifndef GLEE_C_DEFINED_glCompileShader
#define GLEE_C_DEFINED_glCompileShader
  void __stdcall GLee_Lazy_glCompileShader(GLuint shader)  {if (GLeeInit()) glCompileShader(shader);}
  GLEEPFNGLCOMPILESHADERPROC GLeeFuncPtr_glCompileShader=GLee_Lazy_glCompileShader;
#endif
#ifndef GLEE_C_DEFINED_glCreateProgram
#define GLEE_C_DEFINED_glCreateProgram
  GLuint __stdcall GLee_Lazy_glCreateProgram(void)  {if (GLeeInit()) return glCreateProgram(); return (GLuint)0;}
  GLEEPFNGLCREATEPROGRAMPROC GLeeFuncPtr_glCreateProgram=GLee_Lazy_glCreateProgram;
#endif
#ifndef GLEE_C_DEFINED_glCreateShader
#define GLEE_C_DEFINED_glCreateShader
  GLuint __stdcall GLee_Lazy_glCreateShader(GLenum type)  {if (GLeeInit()) return glCreateShader(type); return (GLuint)0;}
  GLEEPFNGLCREATESHADERPROC GLeeFuncPtr_glCreateShader=GLee_Lazy_glCreateShader;
#endif
#ifndef GLEE_C_DEFINED_glDeleteProgram
#define GLEE_C_DEFINED_glDeleteProgram
  void __stdcall GLee_Lazy_glDeleteProgram(GLuint program)  {if (GLeeInit()) glDeleteProgram(program);}
  GLEEPFNGLDELETEPROGRAMPROC GLeeFuncPtr_glDeleteProgram=GLee_Lazy_glDeleteProgram;
#endif
#ifndef GLEE_C_DEFINED_glDeleteShader
#define GLEE_C_DEFINED_glDeleteShader
  void __stdcall GLee_Lazy_glDeleteShader(GLuint shader)  {if (GLeeInit()) glDeleteShader(shader);}
  GLEEPFNGLDELETESHADERPROC GLeeFuncPtr_glDeleteShader=GLee_Lazy_glDeleteShader;
#endif
#ifndef GLEE_C_DEFINED_glDetachShader
#define GLEE_C_DEFINED_glDetachShader
  void __stdcall GLee_Lazy_glDetachShader(GLuint program, GLuint shader)  {if (GLeeInit()) glDetachShader(program, shader);}
  GLEEPFNGLDETACHSHADERPROC GLeeFuncPtr_glDetachShader=GLee_Lazy_glDetachShader;
#endif
#ifndef GLEE_C_DEFINED_glDisableVertexAttribArray
#define GLEE_C_DEFINED_glDisableVertexAttribArray
  void __stdcall GLee_Lazy_glDisableVertexAttribArray(GLuint index)  {if (GLeeInit()) glDisableVertexAttribArray(index);}
  GLEEPFNGLDISABLEVERTEXATTRIBARRAYPROC GLeeFuncPtr_glDisableVertexAttribArray=GLee_Lazy_glDisableVertexAttribArray;
#endif
#ifndef GLEE_C_DEFINED_glEnableVertexAttribArray
#define GLEE_C_DEFINED_glEnableVertexAttribArray
  void __stdcall GLee_Lazy_glEnableVertexAttribArray(GLuint index)  {if (GLeeInit()) glEnableVertexAttribArray(index);}
  GLEEPFNGLENABLEVERTEXATTRIBARRAYPROC GLeeFuncPtr_glEnableVertexAttribArray=GLee_Lazy_glEnableVertexAttribArray;
#endif
#ifndef GLEE_C_DEFINED_glGetActiveAttrib
#define GLEE_C_DEFINED_glGetActiveAttrib
  void __stdcall GLee_Lazy_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name)  {if (GLeeInit()) glGetActiveAttrib(program, index, bufSize, length, size, type, name);}
  GLEEPFNGLGETACTIVEATTRIBPROC GLeeFuncPtr_glGetActiveAttrib=GLee_Lazy_glGetActiveAttrib;
#endif
#ifndef GLEE_C_DEFINED_glGetActiveUniform
#define GLEE_C_DEFINED_glGetActiveUniform
  void __stdcall GLee_Lazy_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name)  {if (GLeeInit()) glGetActiveUniform(program, index, bufSize, length, size, type, name);}
  GLEEPFNGLGETACTIVEUNIFORMPROC GLeeFuncPtr_glGetActiveUniform=GLee_Lazy_glGetActiveUniform;
#endif
#ifndef GLEE_C_DEFINED_glGetAttachedShaders
#define GLEE_C_DEFINED_glGetAttachedShaders
  void __stdcall GLee_Lazy_glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * obj)  {if (GLeeInit()) glGetAttachedShaders(program, maxCount, count, obj);}
  GLEEPFNGLGETATTACHEDSHADERSPROC GLeeFuncPtr_glGetAttachedShaders=GLee_Lazy_glGetAttachedShaders;
#endif
#ifndef GLEE_C_DEFINED_glGetAttribLocation
#define GLEE_C_DEFINED_glGetAttribLocation
  GLint __stdcall GLee_Lazy_glGetAttribLocation(GLuint program, const GLchar * name)  {if (GLeeInit()) return glGetAttribLocation(program, name); return (GLint)0;}
  GLEEPFNGLGETATTRIBLOCATIONPROC GLeeFuncPtr_glGetAttribLocation=GLee_Lazy_glGetAttribLocation;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramiv
#define GLEE_C_DEFINED_glGetProgramiv
  void __stdcall GLee_Lazy_glGetProgramiv(GLuint program, GLenum pname, GLint * params)  {if (GLeeInit()) glGetProgramiv(program, pname, params);}
  GLEEPFNGLGETPROGRAMIVPROC GLeeFuncPtr_glGetProgramiv=GLee_Lazy_glGetProgramiv;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramInfoLog
#define GLEE_C_DEFINED_glGetProgramInfoLog
  void __stdcall GLee_Lazy_glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog)  {if (GLeeInit()) glGetProgramInfoLog(program, bufSize, length, infoLog);}
  GLEEPFNGLGETPROGRAMINFOLOGPROC GLeeFuncPtr_glGetProgramInfoLog=GLee_Lazy_glGetProgramInfoLog;
#endif
#ifndef GLEE_C_DEFINED_glGetShaderiv
#define GLEE_C_DEFINED_glGetShaderiv
  void __stdcall GLee_Lazy_glGetShaderiv(GLuint shader, GLenum pname, GLint * params)  {if (GLeeInit()) glGetShaderiv(shader, pname, params);}
  GLEEPFNGLGETSHADERIVPROC GLeeFuncPtr_glGetShaderiv=GLee_Lazy_glGetShaderiv;
#endif
#ifndef GLEE_C_DEFINED_glGetShaderInfoLog
#define GLEE_C_DEFINED_glGetShaderInfoLog
  void __stdcall GLee_Lazy_glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog)  {if (GLeeInit()) glGetShaderInfoLog(shader, bufSize, length, infoLog);}
  GLEEPFNGLGETSHADERINFOLOGPROC GLeeFuncPtr_glGetShaderInfoLog=GLee_Lazy_glGetShaderInfoLog;
#endif
#ifndef GLEE_C_DEFINED_glGetShaderSource
#define GLEE_C_DEFINED_glGetShaderSource
  void __stdcall GLee_Lazy_glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source)  {if (GLeeInit()) glGetShaderSource(shader, bufSize, length, source);}
  GLEEPFNGLGETSHADERSOURCEPROC GLeeFuncPtr_glGetShaderSource=GLee_Lazy_glGetShaderSource;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformLocation
#define GLEE_C_DEFINED_glGetUniformLocation
  GLint __stdcall GLee_Lazy_glGetUniformLocation(GLuint program, const GLchar * name)  {if (GLeeInit()) return glGetUniformLocation(program, name); return (GLint)0;}
  GLEEPFNGLGETUNIFORMLOCATIONPROC GLeeFuncPtr_glGetUniformLocation=GLee_Lazy_glGetUniformLocation;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformfv
#define GLEE_C_DEFINED_glGetUniformfv
  void __stdcall GLee_Lazy_glGetUniformfv(GLuint program, GLint location, GLfloat * params)  {if (GLeeInit()) glGetUniformfv(program, location, params);}
  GLEEPFNGLGETUNIFORMFVPROC GLeeFuncPtr_glGetUniformfv=GLee_Lazy_glGetUniformfv;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformiv
#define GLEE_C_DEFINED_glGetUniformiv
  void __stdcall GLee_Lazy_glGetUniformiv(GLuint program, GLint location, GLint * params)  {if (GLeeInit()) glGetUniformiv(program, location, params);}
  GLEEPFNGLGETUNIFORMIVPROC GLeeFuncPtr_glGetUniformiv=GLee_Lazy_glGetUniformiv;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribdv
#define GLEE_C_DEFINED_glGetVertexAttribdv
  void __stdcall GLee_Lazy_glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble * params)  {if (GLeeInit()) glGetVertexAttribdv(index, pname, params);}
  GLEEPFNGLGETVERTEXATTRIBDVPROC GLeeFuncPtr_glGetVertexAttribdv=GLee_Lazy_glGetVertexAttribdv;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribfv
#define GLEE_C_DEFINED_glGetVertexAttribfv
  void __stdcall GLee_Lazy_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetVertexAttribfv(index, pname, params);}
  GLEEPFNGLGETVERTEXATTRIBFVPROC GLeeFuncPtr_glGetVertexAttribfv=GLee_Lazy_glGetVertexAttribfv;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribiv
#define GLEE_C_DEFINED_glGetVertexAttribiv
  void __stdcall GLee_Lazy_glGetVertexAttribiv(GLuint index, GLenum pname, GLint * params)  {if (GLeeInit()) glGetVertexAttribiv(index, pname, params);}
  GLEEPFNGLGETVERTEXATTRIBIVPROC GLeeFuncPtr_glGetVertexAttribiv=GLee_Lazy_glGetVertexAttribiv;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribPointerv
#define GLEE_C_DEFINED_glGetVertexAttribPointerv
  void __stdcall GLee_Lazy_glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* * pointer)  {if (GLeeInit()) glGetVertexAttribPointerv(index, pname, pointer);}
  GLEEPFNGLGETVERTEXATTRIBPOINTERVPROC GLeeFuncPtr_glGetVertexAttribPointerv=GLee_Lazy_glGetVertexAttribPointerv;
#endif
#ifndef GLEE_C_DEFINED_glIsProgram
#define GLEE_C_DEFINED_glIsProgram
  GLboolean __stdcall GLee_Lazy_glIsProgram(GLuint program)  {if (GLeeInit()) return glIsProgram(program); return (GLboolean)0;}
  GLEEPFNGLISPROGRAMPROC GLeeFuncPtr_glIsProgram=GLee_Lazy_glIsProgram;
#endif
#ifndef GLEE_C_DEFINED_glIsShader
#define GLEE_C_DEFINED_glIsShader
  GLboolean __stdcall GLee_Lazy_glIsShader(GLuint shader)  {if (GLeeInit()) return glIsShader(shader); return (GLboolean)0;}
  GLEEPFNGLISSHADERPROC GLeeFuncPtr_glIsShader=GLee_Lazy_glIsShader;
#endif
#ifndef GLEE_C_DEFINED_glLinkProgram
#define GLEE_C_DEFINED_glLinkProgram
  void __stdcall GLee_Lazy_glLinkProgram(GLuint program)  {if (GLeeInit()) glLinkProgram(program);}
  GLEEPFNGLLINKPROGRAMPROC GLeeFuncPtr_glLinkProgram=GLee_Lazy_glLinkProgram;
#endif
#ifndef GLEE_C_DEFINED_glShaderSource
#define GLEE_C_DEFINED_glShaderSource
  void __stdcall GLee_Lazy_glShaderSource(GLuint shader, GLsizei count, const GLchar* * string, const GLint * length)  {if (GLeeInit()) glShaderSource(shader, count, string, length);}
  GLEEPFNGLSHADERSOURCEPROC GLeeFuncPtr_glShaderSource=GLee_Lazy_glShaderSource;
#endif
#ifndef GLEE_C_DEFINED_glUseProgram
#define GLEE_C_DEFINED_glUseProgram
  void __stdcall GLee_Lazy_glUseProgram(GLuint program)  {if (GLeeInit()) glUseProgram(program);}
  GLEEPFNGLUSEPROGRAMPROC GLeeFuncPtr_glUseProgram=GLee_Lazy_glUseProgram;
#endif
#ifndef GLEE_C_DEFINED_glUniform1f
#define GLEE_C_DEFINED_glUniform1f
  void __stdcall GLee_Lazy_glUniform1f(GLint location, GLfloat v0)  {if (GLeeInit()) glUniform1f(location, v0);}
  GLEEPFNGLUNIFORM1FPROC GLeeFuncPtr_glUniform1f=GLee_Lazy_glUniform1f;
#endif
#ifndef GLEE_C_DEFINED_glUniform2f
#define GLEE_C_DEFINED_glUniform2f
  void __stdcall GLee_Lazy_glUniform2f(GLint location, GLfloat v0, GLfloat v1)  {if (GLeeInit()) glUniform2f(location, v0, v1);}
  GLEEPFNGLUNIFORM2FPROC GLeeFuncPtr_glUniform2f=GLee_Lazy_glUniform2f;
#endif
#ifndef GLEE_C_DEFINED_glUniform3f
#define GLEE_C_DEFINED_glUniform3f
  void __stdcall GLee_Lazy_glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)  {if (GLeeInit()) glUniform3f(location, v0, v1, v2);}
  GLEEPFNGLUNIFORM3FPROC GLeeFuncPtr_glUniform3f=GLee_Lazy_glUniform3f;
#endif
#ifndef GLEE_C_DEFINED_glUniform4f
#define GLEE_C_DEFINED_glUniform4f
  void __stdcall GLee_Lazy_glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)  {if (GLeeInit()) glUniform4f(location, v0, v1, v2, v3);}
  GLEEPFNGLUNIFORM4FPROC GLeeFuncPtr_glUniform4f=GLee_Lazy_glUniform4f;
#endif
#ifndef GLEE_C_DEFINED_glUniform1i
#define GLEE_C_DEFINED_glUniform1i
  void __stdcall GLee_Lazy_glUniform1i(GLint location, GLint v0)  {if (GLeeInit()) glUniform1i(location, v0);}
  GLEEPFNGLUNIFORM1IPROC GLeeFuncPtr_glUniform1i=GLee_Lazy_glUniform1i;
#endif
#ifndef GLEE_C_DEFINED_glUniform2i
#define GLEE_C_DEFINED_glUniform2i
  void __stdcall GLee_Lazy_glUniform2i(GLint location, GLint v0, GLint v1)  {if (GLeeInit()) glUniform2i(location, v0, v1);}
  GLEEPFNGLUNIFORM2IPROC GLeeFuncPtr_glUniform2i=GLee_Lazy_glUniform2i;
#endif
#ifndef GLEE_C_DEFINED_glUniform3i
#define GLEE_C_DEFINED_glUniform3i
  void __stdcall GLee_Lazy_glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)  {if (GLeeInit()) glUniform3i(location, v0, v1, v2);}
  GLEEPFNGLUNIFORM3IPROC GLeeFuncPtr_glUniform3i=GLee_Lazy_glUniform3i;
#endif
#ifndef GLEE_C_DEFINED_glUniform4i
#define GLEE_C_DEFINED_glUniform4i
  void __stdcall GLee_Lazy_glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)  {if (GLeeInit()) glUniform4i(location, v0, v1, v2, v3);}
  GLEEPFNGLUNIFORM4IPROC GLeeFuncPtr_glUniform4i=GLee_Lazy_glUniform4i;
#endif
#ifndef GLEE_C_DEFINED_glUniform1fv
#define GLEE_C_DEFINED_glUniform1fv
  void __stdcall GLee_Lazy_glUniform1fv(GLint location, GLsizei count, const GLfloat * value)  {if (GLeeInit()) glUniform1fv(location, count, value);}
  GLEEPFNGLUNIFORM1FVPROC GLeeFuncPtr_glUniform1fv=GLee_Lazy_glUniform1fv;
#endif
#ifndef GLEE_C_DEFINED_glUniform2fv
#define GLEE_C_DEFINED_glUniform2fv
  void __stdcall GLee_Lazy_glUniform2fv(GLint location, GLsizei count, const GLfloat * value)  {if (GLeeInit()) glUniform2fv(location, count, value);}
  GLEEPFNGLUNIFORM2FVPROC GLeeFuncPtr_glUniform2fv=GLee_Lazy_glUniform2fv;
#endif
#ifndef GLEE_C_DEFINED_glUniform3fv
#define GLEE_C_DEFINED_glUniform3fv
  void __stdcall GLee_Lazy_glUniform3fv(GLint location, GLsizei count, const GLfloat * value)  {if (GLeeInit()) glUniform3fv(location, count, value);}
  GLEEPFNGLUNIFORM3FVPROC GLeeFuncPtr_glUniform3fv=GLee_Lazy_glUniform3fv;
#endif
#ifndef GLEE_C_DEFINED_glUniform4fv
#define GLEE_C_DEFINED_glUniform4fv
  void __stdcall GLee_Lazy_glUniform4fv(GLint location, GLsizei count, const GLfloat * value)  {if (GLeeInit()) glUniform4fv(location, count, value);}
  GLEEPFNGLUNIFORM4FVPROC GLeeFuncPtr_glUniform4fv=GLee_Lazy_glUniform4fv;
#endif
#ifndef GLEE_C_DEFINED_glUniform1iv
#define GLEE_C_DEFINED_glUniform1iv
  void __stdcall GLee_Lazy_glUniform1iv(GLint location, GLsizei count, const GLint * value)  {if (GLeeInit()) glUniform1iv(location, count, value);}
  GLEEPFNGLUNIFORM1IVPROC GLeeFuncPtr_glUniform1iv=GLee_Lazy_glUniform1iv;
#endif
#ifndef GLEE_C_DEFINED_glUniform2iv
#define GLEE_C_DEFINED_glUniform2iv
  void __stdcall GLee_Lazy_glUniform2iv(GLint location, GLsizei count, const GLint * value)  {if (GLeeInit()) glUniform2iv(location, count, value);}
  GLEEPFNGLUNIFORM2IVPROC GLeeFuncPtr_glUniform2iv=GLee_Lazy_glUniform2iv;
#endif
#ifndef GLEE_C_DEFINED_glUniform3iv
#define GLEE_C_DEFINED_glUniform3iv
  void __stdcall GLee_Lazy_glUniform3iv(GLint location, GLsizei count, const GLint * value)  {if (GLeeInit()) glUniform3iv(location, count, value);}
  GLEEPFNGLUNIFORM3IVPROC GLeeFuncPtr_glUniform3iv=GLee_Lazy_glUniform3iv;
#endif
#ifndef GLEE_C_DEFINED_glUniform4iv
#define GLEE_C_DEFINED_glUniform4iv
  void __stdcall GLee_Lazy_glUniform4iv(GLint location, GLsizei count, const GLint * value)  {if (GLeeInit()) glUniform4iv(location, count, value);}
  GLEEPFNGLUNIFORM4IVPROC GLeeFuncPtr_glUniform4iv=GLee_Lazy_glUniform4iv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix2fv
#define GLEE_C_DEFINED_glUniformMatrix2fv
  void __stdcall GLee_Lazy_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glUniformMatrix2fv(location, count, transpose, value);}
  GLEEPFNGLUNIFORMMATRIX2FVPROC GLeeFuncPtr_glUniformMatrix2fv=GLee_Lazy_glUniformMatrix2fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix3fv
#define GLEE_C_DEFINED_glUniformMatrix3fv
  void __stdcall GLee_Lazy_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glUniformMatrix3fv(location, count, transpose, value);}
  GLEEPFNGLUNIFORMMATRIX3FVPROC GLeeFuncPtr_glUniformMatrix3fv=GLee_Lazy_glUniformMatrix3fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix4fv
#define GLEE_C_DEFINED_glUniformMatrix4fv
  void __stdcall GLee_Lazy_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glUniformMatrix4fv(location, count, transpose, value);}
  GLEEPFNGLUNIFORMMATRIX4FVPROC GLeeFuncPtr_glUniformMatrix4fv=GLee_Lazy_glUniformMatrix4fv;
#endif
#ifndef GLEE_C_DEFINED_glValidateProgram
#define GLEE_C_DEFINED_glValidateProgram
  void __stdcall GLee_Lazy_glValidateProgram(GLuint program)  {if (GLeeInit()) glValidateProgram(program);}
  GLEEPFNGLVALIDATEPROGRAMPROC GLeeFuncPtr_glValidateProgram=GLee_Lazy_glValidateProgram;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1d
#define GLEE_C_DEFINED_glVertexAttrib1d
  void __stdcall GLee_Lazy_glVertexAttrib1d(GLuint index, GLdouble x)  {if (GLeeInit()) glVertexAttrib1d(index, x);}
  GLEEPFNGLVERTEXATTRIB1DPROC GLeeFuncPtr_glVertexAttrib1d=GLee_Lazy_glVertexAttrib1d;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1dv
#define GLEE_C_DEFINED_glVertexAttrib1dv
  void __stdcall GLee_Lazy_glVertexAttrib1dv(GLuint index, const GLdouble * v)  {if (GLeeInit()) glVertexAttrib1dv(index, v);}
  GLEEPFNGLVERTEXATTRIB1DVPROC GLeeFuncPtr_glVertexAttrib1dv=GLee_Lazy_glVertexAttrib1dv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1f
#define GLEE_C_DEFINED_glVertexAttrib1f
  void __stdcall GLee_Lazy_glVertexAttrib1f(GLuint index, GLfloat x)  {if (GLeeInit()) glVertexAttrib1f(index, x);}
  GLEEPFNGLVERTEXATTRIB1FPROC GLeeFuncPtr_glVertexAttrib1f=GLee_Lazy_glVertexAttrib1f;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1fv
#define GLEE_C_DEFINED_glVertexAttrib1fv
  void __stdcall GLee_Lazy_glVertexAttrib1fv(GLuint index, const GLfloat * v)  {if (GLeeInit()) glVertexAttrib1fv(index, v);}
  GLEEPFNGLVERTEXATTRIB1FVPROC GLeeFuncPtr_glVertexAttrib1fv=GLee_Lazy_glVertexAttrib1fv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1s
#define GLEE_C_DEFINED_glVertexAttrib1s
  void __stdcall GLee_Lazy_glVertexAttrib1s(GLuint index, GLshort x)  {if (GLeeInit()) glVertexAttrib1s(index, x);}
  GLEEPFNGLVERTEXATTRIB1SPROC GLeeFuncPtr_glVertexAttrib1s=GLee_Lazy_glVertexAttrib1s;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1sv
#define GLEE_C_DEFINED_glVertexAttrib1sv
  void __stdcall GLee_Lazy_glVertexAttrib1sv(GLuint index, const GLshort * v)  {if (GLeeInit()) glVertexAttrib1sv(index, v);}
  GLEEPFNGLVERTEXATTRIB1SVPROC GLeeFuncPtr_glVertexAttrib1sv=GLee_Lazy_glVertexAttrib1sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2d
#define GLEE_C_DEFINED_glVertexAttrib2d
  void __stdcall GLee_Lazy_glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)  {if (GLeeInit()) glVertexAttrib2d(index, x, y);}
  GLEEPFNGLVERTEXATTRIB2DPROC GLeeFuncPtr_glVertexAttrib2d=GLee_Lazy_glVertexAttrib2d;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2dv
#define GLEE_C_DEFINED_glVertexAttrib2dv
  void __stdcall GLee_Lazy_glVertexAttrib2dv(GLuint index, const GLdouble * v)  {if (GLeeInit()) glVertexAttrib2dv(index, v);}
  GLEEPFNGLVERTEXATTRIB2DVPROC GLeeFuncPtr_glVertexAttrib2dv=GLee_Lazy_glVertexAttrib2dv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2f
#define GLEE_C_DEFINED_glVertexAttrib2f
  void __stdcall GLee_Lazy_glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)  {if (GLeeInit()) glVertexAttrib2f(index, x, y);}
  GLEEPFNGLVERTEXATTRIB2FPROC GLeeFuncPtr_glVertexAttrib2f=GLee_Lazy_glVertexAttrib2f;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2fv
#define GLEE_C_DEFINED_glVertexAttrib2fv
  void __stdcall GLee_Lazy_glVertexAttrib2fv(GLuint index, const GLfloat * v)  {if (GLeeInit()) glVertexAttrib2fv(index, v);}
  GLEEPFNGLVERTEXATTRIB2FVPROC GLeeFuncPtr_glVertexAttrib2fv=GLee_Lazy_glVertexAttrib2fv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2s
#define GLEE_C_DEFINED_glVertexAttrib2s
  void __stdcall GLee_Lazy_glVertexAttrib2s(GLuint index, GLshort x, GLshort y)  {if (GLeeInit()) glVertexAttrib2s(index, x, y);}
  GLEEPFNGLVERTEXATTRIB2SPROC GLeeFuncPtr_glVertexAttrib2s=GLee_Lazy_glVertexAttrib2s;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2sv
#define GLEE_C_DEFINED_glVertexAttrib2sv
  void __stdcall GLee_Lazy_glVertexAttrib2sv(GLuint index, const GLshort * v)  {if (GLeeInit()) glVertexAttrib2sv(index, v);}
  GLEEPFNGLVERTEXATTRIB2SVPROC GLeeFuncPtr_glVertexAttrib2sv=GLee_Lazy_glVertexAttrib2sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3d
#define GLEE_C_DEFINED_glVertexAttrib3d
  void __stdcall GLee_Lazy_glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)  {if (GLeeInit()) glVertexAttrib3d(index, x, y, z);}
  GLEEPFNGLVERTEXATTRIB3DPROC GLeeFuncPtr_glVertexAttrib3d=GLee_Lazy_glVertexAttrib3d;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3dv
#define GLEE_C_DEFINED_glVertexAttrib3dv
  void __stdcall GLee_Lazy_glVertexAttrib3dv(GLuint index, const GLdouble * v)  {if (GLeeInit()) glVertexAttrib3dv(index, v);}
  GLEEPFNGLVERTEXATTRIB3DVPROC GLeeFuncPtr_glVertexAttrib3dv=GLee_Lazy_glVertexAttrib3dv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3f
#define GLEE_C_DEFINED_glVertexAttrib3f
  void __stdcall GLee_Lazy_glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glVertexAttrib3f(index, x, y, z);}
  GLEEPFNGLVERTEXATTRIB3FPROC GLeeFuncPtr_glVertexAttrib3f=GLee_Lazy_glVertexAttrib3f;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3fv
#define GLEE_C_DEFINED_glVertexAttrib3fv
  void __stdcall GLee_Lazy_glVertexAttrib3fv(GLuint index, const GLfloat * v)  {if (GLeeInit()) glVertexAttrib3fv(index, v);}
  GLEEPFNGLVERTEXATTRIB3FVPROC GLeeFuncPtr_glVertexAttrib3fv=GLee_Lazy_glVertexAttrib3fv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3s
#define GLEE_C_DEFINED_glVertexAttrib3s
  void __stdcall GLee_Lazy_glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)  {if (GLeeInit()) glVertexAttrib3s(index, x, y, z);}
  GLEEPFNGLVERTEXATTRIB3SPROC GLeeFuncPtr_glVertexAttrib3s=GLee_Lazy_glVertexAttrib3s;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3sv
#define GLEE_C_DEFINED_glVertexAttrib3sv
  void __stdcall GLee_Lazy_glVertexAttrib3sv(GLuint index, const GLshort * v)  {if (GLeeInit()) glVertexAttrib3sv(index, v);}
  GLEEPFNGLVERTEXATTRIB3SVPROC GLeeFuncPtr_glVertexAttrib3sv=GLee_Lazy_glVertexAttrib3sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nbv
#define GLEE_C_DEFINED_glVertexAttrib4Nbv
  void __stdcall GLee_Lazy_glVertexAttrib4Nbv(GLuint index, const GLbyte * v)  {if (GLeeInit()) glVertexAttrib4Nbv(index, v);}
  GLEEPFNGLVERTEXATTRIB4NBVPROC GLeeFuncPtr_glVertexAttrib4Nbv=GLee_Lazy_glVertexAttrib4Nbv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Niv
#define GLEE_C_DEFINED_glVertexAttrib4Niv
  void __stdcall GLee_Lazy_glVertexAttrib4Niv(GLuint index, const GLint * v)  {if (GLeeInit()) glVertexAttrib4Niv(index, v);}
  GLEEPFNGLVERTEXATTRIB4NIVPROC GLeeFuncPtr_glVertexAttrib4Niv=GLee_Lazy_glVertexAttrib4Niv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nsv
#define GLEE_C_DEFINED_glVertexAttrib4Nsv
  void __stdcall GLee_Lazy_glVertexAttrib4Nsv(GLuint index, const GLshort * v)  {if (GLeeInit()) glVertexAttrib4Nsv(index, v);}
  GLEEPFNGLVERTEXATTRIB4NSVPROC GLeeFuncPtr_glVertexAttrib4Nsv=GLee_Lazy_glVertexAttrib4Nsv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nub
#define GLEE_C_DEFINED_glVertexAttrib4Nub
  void __stdcall GLee_Lazy_glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)  {if (GLeeInit()) glVertexAttrib4Nub(index, x, y, z, w);}
  GLEEPFNGLVERTEXATTRIB4NUBPROC GLeeFuncPtr_glVertexAttrib4Nub=GLee_Lazy_glVertexAttrib4Nub;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nubv
#define GLEE_C_DEFINED_glVertexAttrib4Nubv
  void __stdcall GLee_Lazy_glVertexAttrib4Nubv(GLuint index, const GLubyte * v)  {if (GLeeInit()) glVertexAttrib4Nubv(index, v);}
  GLEEPFNGLVERTEXATTRIB4NUBVPROC GLeeFuncPtr_glVertexAttrib4Nubv=GLee_Lazy_glVertexAttrib4Nubv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nuiv
#define GLEE_C_DEFINED_glVertexAttrib4Nuiv
  void __stdcall GLee_Lazy_glVertexAttrib4Nuiv(GLuint index, const GLuint * v)  {if (GLeeInit()) glVertexAttrib4Nuiv(index, v);}
  GLEEPFNGLVERTEXATTRIB4NUIVPROC GLeeFuncPtr_glVertexAttrib4Nuiv=GLee_Lazy_glVertexAttrib4Nuiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nusv
#define GLEE_C_DEFINED_glVertexAttrib4Nusv
  void __stdcall GLee_Lazy_glVertexAttrib4Nusv(GLuint index, const GLushort * v)  {if (GLeeInit()) glVertexAttrib4Nusv(index, v);}
  GLEEPFNGLVERTEXATTRIB4NUSVPROC GLeeFuncPtr_glVertexAttrib4Nusv=GLee_Lazy_glVertexAttrib4Nusv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4bv
#define GLEE_C_DEFINED_glVertexAttrib4bv
  void __stdcall GLee_Lazy_glVertexAttrib4bv(GLuint index, const GLbyte * v)  {if (GLeeInit()) glVertexAttrib4bv(index, v);}
  GLEEPFNGLVERTEXATTRIB4BVPROC GLeeFuncPtr_glVertexAttrib4bv=GLee_Lazy_glVertexAttrib4bv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4d
#define GLEE_C_DEFINED_glVertexAttrib4d
  void __stdcall GLee_Lazy_glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)  {if (GLeeInit()) glVertexAttrib4d(index, x, y, z, w);}
  GLEEPFNGLVERTEXATTRIB4DPROC GLeeFuncPtr_glVertexAttrib4d=GLee_Lazy_glVertexAttrib4d;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4dv
#define GLEE_C_DEFINED_glVertexAttrib4dv
  void __stdcall GLee_Lazy_glVertexAttrib4dv(GLuint index, const GLdouble * v)  {if (GLeeInit()) glVertexAttrib4dv(index, v);}
  GLEEPFNGLVERTEXATTRIB4DVPROC GLeeFuncPtr_glVertexAttrib4dv=GLee_Lazy_glVertexAttrib4dv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4f
#define GLEE_C_DEFINED_glVertexAttrib4f
  void __stdcall GLee_Lazy_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)  {if (GLeeInit()) glVertexAttrib4f(index, x, y, z, w);}
  GLEEPFNGLVERTEXATTRIB4FPROC GLeeFuncPtr_glVertexAttrib4f=GLee_Lazy_glVertexAttrib4f;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4fv
#define GLEE_C_DEFINED_glVertexAttrib4fv
  void __stdcall GLee_Lazy_glVertexAttrib4fv(GLuint index, const GLfloat * v)  {if (GLeeInit()) glVertexAttrib4fv(index, v);}
  GLEEPFNGLVERTEXATTRIB4FVPROC GLeeFuncPtr_glVertexAttrib4fv=GLee_Lazy_glVertexAttrib4fv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4iv
#define GLEE_C_DEFINED_glVertexAttrib4iv
  void __stdcall GLee_Lazy_glVertexAttrib4iv(GLuint index, const GLint * v)  {if (GLeeInit()) glVertexAttrib4iv(index, v);}
  GLEEPFNGLVERTEXATTRIB4IVPROC GLeeFuncPtr_glVertexAttrib4iv=GLee_Lazy_glVertexAttrib4iv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4s
#define GLEE_C_DEFINED_glVertexAttrib4s
  void __stdcall GLee_Lazy_glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)  {if (GLeeInit()) glVertexAttrib4s(index, x, y, z, w);}
  GLEEPFNGLVERTEXATTRIB4SPROC GLeeFuncPtr_glVertexAttrib4s=GLee_Lazy_glVertexAttrib4s;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4sv
#define GLEE_C_DEFINED_glVertexAttrib4sv
  void __stdcall GLee_Lazy_glVertexAttrib4sv(GLuint index, const GLshort * v)  {if (GLeeInit()) glVertexAttrib4sv(index, v);}
  GLEEPFNGLVERTEXATTRIB4SVPROC GLeeFuncPtr_glVertexAttrib4sv=GLee_Lazy_glVertexAttrib4sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4ubv
#define GLEE_C_DEFINED_glVertexAttrib4ubv
  void __stdcall GLee_Lazy_glVertexAttrib4ubv(GLuint index, const GLubyte * v)  {if (GLeeInit()) glVertexAttrib4ubv(index, v);}
  GLEEPFNGLVERTEXATTRIB4UBVPROC GLeeFuncPtr_glVertexAttrib4ubv=GLee_Lazy_glVertexAttrib4ubv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4uiv
#define GLEE_C_DEFINED_glVertexAttrib4uiv
  void __stdcall GLee_Lazy_glVertexAttrib4uiv(GLuint index, const GLuint * v)  {if (GLeeInit()) glVertexAttrib4uiv(index, v);}
  GLEEPFNGLVERTEXATTRIB4UIVPROC GLeeFuncPtr_glVertexAttrib4uiv=GLee_Lazy_glVertexAttrib4uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4usv
#define GLEE_C_DEFINED_glVertexAttrib4usv
  void __stdcall GLee_Lazy_glVertexAttrib4usv(GLuint index, const GLushort * v)  {if (GLeeInit()) glVertexAttrib4usv(index, v);}
  GLEEPFNGLVERTEXATTRIB4USVPROC GLeeFuncPtr_glVertexAttrib4usv=GLee_Lazy_glVertexAttrib4usv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribPointer
#define GLEE_C_DEFINED_glVertexAttribPointer
  void __stdcall GLee_Lazy_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glVertexAttribPointer(index, size, type, normalized, stride, pointer);}
  GLEEPFNGLVERTEXATTRIBPOINTERPROC GLeeFuncPtr_glVertexAttribPointer=GLee_Lazy_glVertexAttribPointer;
#endif
#endif

/* GL_VERSION_2_1 */

#ifdef __GLEE_GL_VERSION_2_1
#ifndef GLEE_C_DEFINED_glUniformMatrix2x3fv
#define GLEE_C_DEFINED_glUniformMatrix2x3fv
  void __stdcall GLee_Lazy_glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glUniformMatrix2x3fv(location, count, transpose, value);}
  GLEEPFNGLUNIFORMMATRIX2X3FVPROC GLeeFuncPtr_glUniformMatrix2x3fv=GLee_Lazy_glUniformMatrix2x3fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix3x2fv
#define GLEE_C_DEFINED_glUniformMatrix3x2fv
  void __stdcall GLee_Lazy_glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glUniformMatrix3x2fv(location, count, transpose, value);}
  GLEEPFNGLUNIFORMMATRIX3X2FVPROC GLeeFuncPtr_glUniformMatrix3x2fv=GLee_Lazy_glUniformMatrix3x2fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix2x4fv
#define GLEE_C_DEFINED_glUniformMatrix2x4fv
  void __stdcall GLee_Lazy_glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glUniformMatrix2x4fv(location, count, transpose, value);}
  GLEEPFNGLUNIFORMMATRIX2X4FVPROC GLeeFuncPtr_glUniformMatrix2x4fv=GLee_Lazy_glUniformMatrix2x4fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix4x2fv
#define GLEE_C_DEFINED_glUniformMatrix4x2fv
  void __stdcall GLee_Lazy_glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glUniformMatrix4x2fv(location, count, transpose, value);}
  GLEEPFNGLUNIFORMMATRIX4X2FVPROC GLeeFuncPtr_glUniformMatrix4x2fv=GLee_Lazy_glUniformMatrix4x2fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix3x4fv
#define GLEE_C_DEFINED_glUniformMatrix3x4fv
  void __stdcall GLee_Lazy_glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glUniformMatrix3x4fv(location, count, transpose, value);}
  GLEEPFNGLUNIFORMMATRIX3X4FVPROC GLeeFuncPtr_glUniformMatrix3x4fv=GLee_Lazy_glUniformMatrix3x4fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix4x3fv
#define GLEE_C_DEFINED_glUniformMatrix4x3fv
  void __stdcall GLee_Lazy_glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glUniformMatrix4x3fv(location, count, transpose, value);}
  GLEEPFNGLUNIFORMMATRIX4X3FVPROC GLeeFuncPtr_glUniformMatrix4x3fv=GLee_Lazy_glUniformMatrix4x3fv;
#endif
#endif

/* GL_VERSION_3_0 */

#ifdef __GLEE_GL_VERSION_3_0
#ifndef GLEE_C_DEFINED_glColorMaski
#define GLEE_C_DEFINED_glColorMaski
  void __stdcall GLee_Lazy_glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)  {if (GLeeInit()) glColorMaski(index, r, g, b, a);}
  GLEEPFNGLCOLORMASKIPROC GLeeFuncPtr_glColorMaski=GLee_Lazy_glColorMaski;
#endif
#ifndef GLEE_C_DEFINED_glGetBooleani_v
#define GLEE_C_DEFINED_glGetBooleani_v
  void __stdcall GLee_Lazy_glGetBooleani_v(GLenum target, GLuint index, GLboolean * data)  {if (GLeeInit()) glGetBooleani_v(target, index, data);}
  GLEEPFNGLGETBOOLEANI_VPROC GLeeFuncPtr_glGetBooleani_v=GLee_Lazy_glGetBooleani_v;
#endif
#ifndef GLEE_C_DEFINED_glGetIntegeri_v
#define GLEE_C_DEFINED_glGetIntegeri_v
  void __stdcall GLee_Lazy_glGetIntegeri_v(GLenum target, GLuint index, GLint * data)  {if (GLeeInit()) glGetIntegeri_v(target, index, data);}
  GLEEPFNGLGETINTEGERI_VPROC GLeeFuncPtr_glGetIntegeri_v=GLee_Lazy_glGetIntegeri_v;
#endif
#ifndef GLEE_C_DEFINED_glEnablei
#define GLEE_C_DEFINED_glEnablei
  void __stdcall GLee_Lazy_glEnablei(GLenum target, GLuint index)  {if (GLeeInit()) glEnablei(target, index);}
  GLEEPFNGLENABLEIPROC GLeeFuncPtr_glEnablei=GLee_Lazy_glEnablei;
#endif
#ifndef GLEE_C_DEFINED_glDisablei
#define GLEE_C_DEFINED_glDisablei
  void __stdcall GLee_Lazy_glDisablei(GLenum target, GLuint index)  {if (GLeeInit()) glDisablei(target, index);}
  GLEEPFNGLDISABLEIPROC GLeeFuncPtr_glDisablei=GLee_Lazy_glDisablei;
#endif
#ifndef GLEE_C_DEFINED_glIsEnabledi
#define GLEE_C_DEFINED_glIsEnabledi
  GLboolean __stdcall GLee_Lazy_glIsEnabledi(GLenum target, GLuint index)  {if (GLeeInit()) return glIsEnabledi(target, index); return (GLboolean)0;}
  GLEEPFNGLISENABLEDIPROC GLeeFuncPtr_glIsEnabledi=GLee_Lazy_glIsEnabledi;
#endif
#ifndef GLEE_C_DEFINED_glBeginTransformFeedback
#define GLEE_C_DEFINED_glBeginTransformFeedback
  void __stdcall GLee_Lazy_glBeginTransformFeedback(GLenum primitiveMode)  {if (GLeeInit()) glBeginTransformFeedback(primitiveMode);}
  GLEEPFNGLBEGINTRANSFORMFEEDBACKPROC GLeeFuncPtr_glBeginTransformFeedback=GLee_Lazy_glBeginTransformFeedback;
#endif
#ifndef GLEE_C_DEFINED_glEndTransformFeedback
#define GLEE_C_DEFINED_glEndTransformFeedback
  void __stdcall GLee_Lazy_glEndTransformFeedback(void)  {if (GLeeInit()) glEndTransformFeedback();}
  GLEEPFNGLENDTRANSFORMFEEDBACKPROC GLeeFuncPtr_glEndTransformFeedback=GLee_Lazy_glEndTransformFeedback;
#endif
#ifndef GLEE_C_DEFINED_glBindBufferRange
#define GLEE_C_DEFINED_glBindBufferRange
  void __stdcall GLee_Lazy_glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)  {if (GLeeInit()) glBindBufferRange(target, index, buffer, offset, size);}
  GLEEPFNGLBINDBUFFERRANGEPROC GLeeFuncPtr_glBindBufferRange=GLee_Lazy_glBindBufferRange;
#endif
#ifndef GLEE_C_DEFINED_glBindBufferBase
#define GLEE_C_DEFINED_glBindBufferBase
  void __stdcall GLee_Lazy_glBindBufferBase(GLenum target, GLuint index, GLuint buffer)  {if (GLeeInit()) glBindBufferBase(target, index, buffer);}
  GLEEPFNGLBINDBUFFERBASEPROC GLeeFuncPtr_glBindBufferBase=GLee_Lazy_glBindBufferBase;
#endif
#ifndef GLEE_C_DEFINED_glTransformFeedbackVaryings
#define GLEE_C_DEFINED_glTransformFeedbackVaryings
  void __stdcall GLee_Lazy_glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode)  {if (GLeeInit()) glTransformFeedbackVaryings(program, count, locations, bufferMode);}
  GLEEPFNGLTRANSFORMFEEDBACKVARYINGSPROC GLeeFuncPtr_glTransformFeedbackVaryings=GLee_Lazy_glTransformFeedbackVaryings;
#endif
#ifndef GLEE_C_DEFINED_glGetTransformFeedbackVarying
#define GLEE_C_DEFINED_glGetTransformFeedbackVarying
  void __stdcall GLee_Lazy_glGetTransformFeedbackVarying(GLuint program, GLuint index, GLint * location)  {if (GLeeInit()) glGetTransformFeedbackVarying(program, index, location);}
  GLEEPFNGLGETTRANSFORMFEEDBACKVARYINGPROC GLeeFuncPtr_glGetTransformFeedbackVarying=GLee_Lazy_glGetTransformFeedbackVarying;
#endif
#ifndef GLEE_C_DEFINED_glClampColor
#define GLEE_C_DEFINED_glClampColor
  void __stdcall GLee_Lazy_glClampColor(GLenum target, GLenum clamp)  {if (GLeeInit()) glClampColor(target, clamp);}
  GLEEPFNGLCLAMPCOLORPROC GLeeFuncPtr_glClampColor=GLee_Lazy_glClampColor;
#endif
#ifndef GLEE_C_DEFINED_glBeginConditionalRender
#define GLEE_C_DEFINED_glBeginConditionalRender
  void __stdcall GLee_Lazy_glBeginConditionalRender(GLuint id, GLenum mode)  {if (GLeeInit()) glBeginConditionalRender(id, mode);}
  GLEEPFNGLBEGINCONDITIONALRENDERPROC GLeeFuncPtr_glBeginConditionalRender=GLee_Lazy_glBeginConditionalRender;
#endif
#ifndef GLEE_C_DEFINED_glEndConditionalRender
#define GLEE_C_DEFINED_glEndConditionalRender
  void __stdcall GLee_Lazy_glEndConditionalRender(void)  {if (GLeeInit()) glEndConditionalRender();}
  GLEEPFNGLENDCONDITIONALRENDERPROC GLeeFuncPtr_glEndConditionalRender=GLee_Lazy_glEndConditionalRender;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI1i
#define GLEE_C_DEFINED_glVertexAttribI1i
  void __stdcall GLee_Lazy_glVertexAttribI1i(GLuint index, GLint x)  {if (GLeeInit()) glVertexAttribI1i(index, x);}
  GLEEPFNGLVERTEXATTRIBI1IPROC GLeeFuncPtr_glVertexAttribI1i=GLee_Lazy_glVertexAttribI1i;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI2i
#define GLEE_C_DEFINED_glVertexAttribI2i
  void __stdcall GLee_Lazy_glVertexAttribI2i(GLuint index, GLint x, GLint y)  {if (GLeeInit()) glVertexAttribI2i(index, x, y);}
  GLEEPFNGLVERTEXATTRIBI2IPROC GLeeFuncPtr_glVertexAttribI2i=GLee_Lazy_glVertexAttribI2i;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3i
#define GLEE_C_DEFINED_glVertexAttribI3i
  void __stdcall GLee_Lazy_glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)  {if (GLeeInit()) glVertexAttribI3i(index, x, y, z);}
  GLEEPFNGLVERTEXATTRIBI3IPROC GLeeFuncPtr_glVertexAttribI3i=GLee_Lazy_glVertexAttribI3i;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4i
#define GLEE_C_DEFINED_glVertexAttribI4i
  void __stdcall GLee_Lazy_glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)  {if (GLeeInit()) glVertexAttribI4i(index, x, y, z, w);}
  GLEEPFNGLVERTEXATTRIBI4IPROC GLeeFuncPtr_glVertexAttribI4i=GLee_Lazy_glVertexAttribI4i;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI1ui
#define GLEE_C_DEFINED_glVertexAttribI1ui
  void __stdcall GLee_Lazy_glVertexAttribI1ui(GLuint index, GLuint x)  {if (GLeeInit()) glVertexAttribI1ui(index, x);}
  GLEEPFNGLVERTEXATTRIBI1UIPROC GLeeFuncPtr_glVertexAttribI1ui=GLee_Lazy_glVertexAttribI1ui;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI2ui
#define GLEE_C_DEFINED_glVertexAttribI2ui
  void __stdcall GLee_Lazy_glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)  {if (GLeeInit()) glVertexAttribI2ui(index, x, y);}
  GLEEPFNGLVERTEXATTRIBI2UIPROC GLeeFuncPtr_glVertexAttribI2ui=GLee_Lazy_glVertexAttribI2ui;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3ui
#define GLEE_C_DEFINED_glVertexAttribI3ui
  void __stdcall GLee_Lazy_glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)  {if (GLeeInit()) glVertexAttribI3ui(index, x, y, z);}
  GLEEPFNGLVERTEXATTRIBI3UIPROC GLeeFuncPtr_glVertexAttribI3ui=GLee_Lazy_glVertexAttribI3ui;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4ui
#define GLEE_C_DEFINED_glVertexAttribI4ui
  void __stdcall GLee_Lazy_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)  {if (GLeeInit()) glVertexAttribI4ui(index, x, y, z, w);}
  GLEEPFNGLVERTEXATTRIBI4UIPROC GLeeFuncPtr_glVertexAttribI4ui=GLee_Lazy_glVertexAttribI4ui;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI1iv
#define GLEE_C_DEFINED_glVertexAttribI1iv
  void __stdcall GLee_Lazy_glVertexAttribI1iv(GLuint index, const GLint * v)  {if (GLeeInit()) glVertexAttribI1iv(index, v);}
  GLEEPFNGLVERTEXATTRIBI1IVPROC GLeeFuncPtr_glVertexAttribI1iv=GLee_Lazy_glVertexAttribI1iv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI2iv
#define GLEE_C_DEFINED_glVertexAttribI2iv
  void __stdcall GLee_Lazy_glVertexAttribI2iv(GLuint index, const GLint * v)  {if (GLeeInit()) glVertexAttribI2iv(index, v);}
  GLEEPFNGLVERTEXATTRIBI2IVPROC GLeeFuncPtr_glVertexAttribI2iv=GLee_Lazy_glVertexAttribI2iv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3iv
#define GLEE_C_DEFINED_glVertexAttribI3iv
  void __stdcall GLee_Lazy_glVertexAttribI3iv(GLuint index, const GLint * v)  {if (GLeeInit()) glVertexAttribI3iv(index, v);}
  GLEEPFNGLVERTEXATTRIBI3IVPROC GLeeFuncPtr_glVertexAttribI3iv=GLee_Lazy_glVertexAttribI3iv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4iv
#define GLEE_C_DEFINED_glVertexAttribI4iv
  void __stdcall GLee_Lazy_glVertexAttribI4iv(GLuint index, const GLint * v)  {if (GLeeInit()) glVertexAttribI4iv(index, v);}
  GLEEPFNGLVERTEXATTRIBI4IVPROC GLeeFuncPtr_glVertexAttribI4iv=GLee_Lazy_glVertexAttribI4iv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI1uiv
#define GLEE_C_DEFINED_glVertexAttribI1uiv
  void __stdcall GLee_Lazy_glVertexAttribI1uiv(GLuint index, const GLuint * v)  {if (GLeeInit()) glVertexAttribI1uiv(index, v);}
  GLEEPFNGLVERTEXATTRIBI1UIVPROC GLeeFuncPtr_glVertexAttribI1uiv=GLee_Lazy_glVertexAttribI1uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI2uiv
#define GLEE_C_DEFINED_glVertexAttribI2uiv
  void __stdcall GLee_Lazy_glVertexAttribI2uiv(GLuint index, const GLuint * v)  {if (GLeeInit()) glVertexAttribI2uiv(index, v);}
  GLEEPFNGLVERTEXATTRIBI2UIVPROC GLeeFuncPtr_glVertexAttribI2uiv=GLee_Lazy_glVertexAttribI2uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3uiv
#define GLEE_C_DEFINED_glVertexAttribI3uiv
  void __stdcall GLee_Lazy_glVertexAttribI3uiv(GLuint index, const GLuint * v)  {if (GLeeInit()) glVertexAttribI3uiv(index, v);}
  GLEEPFNGLVERTEXATTRIBI3UIVPROC GLeeFuncPtr_glVertexAttribI3uiv=GLee_Lazy_glVertexAttribI3uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4uiv
#define GLEE_C_DEFINED_glVertexAttribI4uiv
  void __stdcall GLee_Lazy_glVertexAttribI4uiv(GLuint index, const GLuint * v)  {if (GLeeInit()) glVertexAttribI4uiv(index, v);}
  GLEEPFNGLVERTEXATTRIBI4UIVPROC GLeeFuncPtr_glVertexAttribI4uiv=GLee_Lazy_glVertexAttribI4uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4bv
#define GLEE_C_DEFINED_glVertexAttribI4bv
  void __stdcall GLee_Lazy_glVertexAttribI4bv(GLuint index, const GLbyte * v)  {if (GLeeInit()) glVertexAttribI4bv(index, v);}
  GLEEPFNGLVERTEXATTRIBI4BVPROC GLeeFuncPtr_glVertexAttribI4bv=GLee_Lazy_glVertexAttribI4bv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4sv
#define GLEE_C_DEFINED_glVertexAttribI4sv
  void __stdcall GLee_Lazy_glVertexAttribI4sv(GLuint index, const GLshort * v)  {if (GLeeInit()) glVertexAttribI4sv(index, v);}
  GLEEPFNGLVERTEXATTRIBI4SVPROC GLeeFuncPtr_glVertexAttribI4sv=GLee_Lazy_glVertexAttribI4sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4ubv
#define GLEE_C_DEFINED_glVertexAttribI4ubv
  void __stdcall GLee_Lazy_glVertexAttribI4ubv(GLuint index, const GLubyte * v)  {if (GLeeInit()) glVertexAttribI4ubv(index, v);}
  GLEEPFNGLVERTEXATTRIBI4UBVPROC GLeeFuncPtr_glVertexAttribI4ubv=GLee_Lazy_glVertexAttribI4ubv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4usv
#define GLEE_C_DEFINED_glVertexAttribI4usv
  void __stdcall GLee_Lazy_glVertexAttribI4usv(GLuint index, const GLushort * v)  {if (GLeeInit()) glVertexAttribI4usv(index, v);}
  GLEEPFNGLVERTEXATTRIBI4USVPROC GLeeFuncPtr_glVertexAttribI4usv=GLee_Lazy_glVertexAttribI4usv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribIPointer
#define GLEE_C_DEFINED_glVertexAttribIPointer
  void __stdcall GLee_Lazy_glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glVertexAttribIPointer(index, size, type, stride, pointer);}
  GLEEPFNGLVERTEXATTRIBIPOINTERPROC GLeeFuncPtr_glVertexAttribIPointer=GLee_Lazy_glVertexAttribIPointer;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribIiv
#define GLEE_C_DEFINED_glGetVertexAttribIiv
  void __stdcall GLee_Lazy_glGetVertexAttribIiv(GLuint index, GLenum pname, GLint * params)  {if (GLeeInit()) glGetVertexAttribIiv(index, pname, params);}
  GLEEPFNGLGETVERTEXATTRIBIIVPROC GLeeFuncPtr_glGetVertexAttribIiv=GLee_Lazy_glGetVertexAttribIiv;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribIuiv
#define GLEE_C_DEFINED_glGetVertexAttribIuiv
  void __stdcall GLee_Lazy_glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint * params)  {if (GLeeInit()) glGetVertexAttribIuiv(index, pname, params);}
  GLEEPFNGLGETVERTEXATTRIBIUIVPROC GLeeFuncPtr_glGetVertexAttribIuiv=GLee_Lazy_glGetVertexAttribIuiv;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformuiv
#define GLEE_C_DEFINED_glGetUniformuiv
  void __stdcall GLee_Lazy_glGetUniformuiv(GLuint program, GLint location, GLuint * params)  {if (GLeeInit()) glGetUniformuiv(program, location, params);}
  GLEEPFNGLGETUNIFORMUIVPROC GLeeFuncPtr_glGetUniformuiv=GLee_Lazy_glGetUniformuiv;
#endif
#ifndef GLEE_C_DEFINED_glBindFragDataLocation
#define GLEE_C_DEFINED_glBindFragDataLocation
  void __stdcall GLee_Lazy_glBindFragDataLocation(GLuint program, GLuint color, const GLchar * name)  {if (GLeeInit()) glBindFragDataLocation(program, color, name);}
  GLEEPFNGLBINDFRAGDATALOCATIONPROC GLeeFuncPtr_glBindFragDataLocation=GLee_Lazy_glBindFragDataLocation;
#endif
#ifndef GLEE_C_DEFINED_glGetFragDataLocation
#define GLEE_C_DEFINED_glGetFragDataLocation
  GLint __stdcall GLee_Lazy_glGetFragDataLocation(GLuint program, const GLchar * name)  {if (GLeeInit()) return glGetFragDataLocation(program, name); return (GLint)0;}
  GLEEPFNGLGETFRAGDATALOCATIONPROC GLeeFuncPtr_glGetFragDataLocation=GLee_Lazy_glGetFragDataLocation;
#endif
#ifndef GLEE_C_DEFINED_glUniform1ui
#define GLEE_C_DEFINED_glUniform1ui
  void __stdcall GLee_Lazy_glUniform1ui(GLint location, GLuint v0)  {if (GLeeInit()) glUniform1ui(location, v0);}
  GLEEPFNGLUNIFORM1UIPROC GLeeFuncPtr_glUniform1ui=GLee_Lazy_glUniform1ui;
#endif
#ifndef GLEE_C_DEFINED_glUniform2ui
#define GLEE_C_DEFINED_glUniform2ui
  void __stdcall GLee_Lazy_glUniform2ui(GLint location, GLuint v0, GLuint v1)  {if (GLeeInit()) glUniform2ui(location, v0, v1);}
  GLEEPFNGLUNIFORM2UIPROC GLeeFuncPtr_glUniform2ui=GLee_Lazy_glUniform2ui;
#endif
#ifndef GLEE_C_DEFINED_glUniform3ui
#define GLEE_C_DEFINED_glUniform3ui
  void __stdcall GLee_Lazy_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)  {if (GLeeInit()) glUniform3ui(location, v0, v1, v2);}
  GLEEPFNGLUNIFORM3UIPROC GLeeFuncPtr_glUniform3ui=GLee_Lazy_glUniform3ui;
#endif
#ifndef GLEE_C_DEFINED_glUniform4ui
#define GLEE_C_DEFINED_glUniform4ui
  void __stdcall GLee_Lazy_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)  {if (GLeeInit()) glUniform4ui(location, v0, v1, v2, v3);}
  GLEEPFNGLUNIFORM4UIPROC GLeeFuncPtr_glUniform4ui=GLee_Lazy_glUniform4ui;
#endif
#ifndef GLEE_C_DEFINED_glUniform1uiv
#define GLEE_C_DEFINED_glUniform1uiv
  void __stdcall GLee_Lazy_glUniform1uiv(GLint location, GLsizei count, const GLuint * value)  {if (GLeeInit()) glUniform1uiv(location, count, value);}
  GLEEPFNGLUNIFORM1UIVPROC GLeeFuncPtr_glUniform1uiv=GLee_Lazy_glUniform1uiv;
#endif
#ifndef GLEE_C_DEFINED_glUniform2uiv
#define GLEE_C_DEFINED_glUniform2uiv
  void __stdcall GLee_Lazy_glUniform2uiv(GLint location, GLsizei count, const GLuint * value)  {if (GLeeInit()) glUniform2uiv(location, count, value);}
  GLEEPFNGLUNIFORM2UIVPROC GLeeFuncPtr_glUniform2uiv=GLee_Lazy_glUniform2uiv;
#endif
#ifndef GLEE_C_DEFINED_glUniform3uiv
#define GLEE_C_DEFINED_glUniform3uiv
  void __stdcall GLee_Lazy_glUniform3uiv(GLint location, GLsizei count, const GLuint * value)  {if (GLeeInit()) glUniform3uiv(location, count, value);}
  GLEEPFNGLUNIFORM3UIVPROC GLeeFuncPtr_glUniform3uiv=GLee_Lazy_glUniform3uiv;
#endif
#ifndef GLEE_C_DEFINED_glUniform4uiv
#define GLEE_C_DEFINED_glUniform4uiv
  void __stdcall GLee_Lazy_glUniform4uiv(GLint location, GLsizei count, const GLuint * value)  {if (GLeeInit()) glUniform4uiv(location, count, value);}
  GLEEPFNGLUNIFORM4UIVPROC GLeeFuncPtr_glUniform4uiv=GLee_Lazy_glUniform4uiv;
#endif
#ifndef GLEE_C_DEFINED_glTexParameterIiv
#define GLEE_C_DEFINED_glTexParameterIiv
  void __stdcall GLee_Lazy_glTexParameterIiv(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glTexParameterIiv(target, pname, params);}
  GLEEPFNGLTEXPARAMETERIIVPROC GLeeFuncPtr_glTexParameterIiv=GLee_Lazy_glTexParameterIiv;
#endif
#ifndef GLEE_C_DEFINED_glTexParameterIuiv
#define GLEE_C_DEFINED_glTexParameterIuiv
  void __stdcall GLee_Lazy_glTexParameterIuiv(GLenum target, GLenum pname, const GLuint * params)  {if (GLeeInit()) glTexParameterIuiv(target, pname, params);}
  GLEEPFNGLTEXPARAMETERIUIVPROC GLeeFuncPtr_glTexParameterIuiv=GLee_Lazy_glTexParameterIuiv;
#endif
#ifndef GLEE_C_DEFINED_glGetTexParameterIiv
#define GLEE_C_DEFINED_glGetTexParameterIiv
  void __stdcall GLee_Lazy_glGetTexParameterIiv(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetTexParameterIiv(target, pname, params);}
  GLEEPFNGLGETTEXPARAMETERIIVPROC GLeeFuncPtr_glGetTexParameterIiv=GLee_Lazy_glGetTexParameterIiv;
#endif
#ifndef GLEE_C_DEFINED_glGetTexParameterIuiv
#define GLEE_C_DEFINED_glGetTexParameterIuiv
  void __stdcall GLee_Lazy_glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint * params)  {if (GLeeInit()) glGetTexParameterIuiv(target, pname, params);}
  GLEEPFNGLGETTEXPARAMETERIUIVPROC GLeeFuncPtr_glGetTexParameterIuiv=GLee_Lazy_glGetTexParameterIuiv;
#endif
#ifndef GLEE_C_DEFINED_glClearBufferiv
#define GLEE_C_DEFINED_glClearBufferiv
  void __stdcall GLee_Lazy_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint * value)  {if (GLeeInit()) glClearBufferiv(buffer, drawbuffer, value);}
  GLEEPFNGLCLEARBUFFERIVPROC GLeeFuncPtr_glClearBufferiv=GLee_Lazy_glClearBufferiv;
#endif
#ifndef GLEE_C_DEFINED_glClearBufferuiv
#define GLEE_C_DEFINED_glClearBufferuiv
  void __stdcall GLee_Lazy_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint * value)  {if (GLeeInit()) glClearBufferuiv(buffer, drawbuffer, value);}
  GLEEPFNGLCLEARBUFFERUIVPROC GLeeFuncPtr_glClearBufferuiv=GLee_Lazy_glClearBufferuiv;
#endif
#ifndef GLEE_C_DEFINED_glClearBufferfv
#define GLEE_C_DEFINED_glClearBufferfv
  void __stdcall GLee_Lazy_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat * value)  {if (GLeeInit()) glClearBufferfv(buffer, drawbuffer, value);}
  GLEEPFNGLCLEARBUFFERFVPROC GLeeFuncPtr_glClearBufferfv=GLee_Lazy_glClearBufferfv;
#endif
#ifndef GLEE_C_DEFINED_glClearBufferfi
#define GLEE_C_DEFINED_glClearBufferfi
  void __stdcall GLee_Lazy_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)  {if (GLeeInit()) glClearBufferfi(buffer, drawbuffer, depth, stencil);}
  GLEEPFNGLCLEARBUFFERFIPROC GLeeFuncPtr_glClearBufferfi=GLee_Lazy_glClearBufferfi;
#endif
#ifndef GLEE_C_DEFINED_glGetStringi
#define GLEE_C_DEFINED_glGetStringi
  const GLubyte * __stdcall GLee_Lazy_glGetStringi(GLenum name, GLuint index)  {if (GLeeInit()) return glGetStringi(name, index); return (const GLubyte *)0;}
  GLEEPFNGLGETSTRINGIPROC GLeeFuncPtr_glGetStringi=GLee_Lazy_glGetStringi;
#endif
#endif

/* GL_ARB_multitexture */

#ifdef __GLEE_GL_ARB_multitexture
#ifndef GLEE_C_DEFINED_glActiveTextureARB
#define GLEE_C_DEFINED_glActiveTextureARB
  void __stdcall GLee_Lazy_glActiveTextureARB(GLenum texture)  {if (GLeeInit()) glActiveTextureARB(texture);}
  GLEEPFNGLACTIVETEXTUREARBPROC GLeeFuncPtr_glActiveTextureARB=GLee_Lazy_glActiveTextureARB;
#endif
#ifndef GLEE_C_DEFINED_glClientActiveTextureARB
#define GLEE_C_DEFINED_glClientActiveTextureARB
  void __stdcall GLee_Lazy_glClientActiveTextureARB(GLenum texture)  {if (GLeeInit()) glClientActiveTextureARB(texture);}
  GLEEPFNGLCLIENTACTIVETEXTUREARBPROC GLeeFuncPtr_glClientActiveTextureARB=GLee_Lazy_glClientActiveTextureARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1dARB
#define GLEE_C_DEFINED_glMultiTexCoord1dARB
  void __stdcall GLee_Lazy_glMultiTexCoord1dARB(GLenum target, GLdouble s)  {if (GLeeInit()) glMultiTexCoord1dARB(target, s);}
  GLEEPFNGLMULTITEXCOORD1DARBPROC GLeeFuncPtr_glMultiTexCoord1dARB=GLee_Lazy_glMultiTexCoord1dARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1dvARB
#define GLEE_C_DEFINED_glMultiTexCoord1dvARB
  void __stdcall GLee_Lazy_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)  {if (GLeeInit()) glMultiTexCoord1dvARB(target, v);}
  GLEEPFNGLMULTITEXCOORD1DVARBPROC GLeeFuncPtr_glMultiTexCoord1dvARB=GLee_Lazy_glMultiTexCoord1dvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1fARB
#define GLEE_C_DEFINED_glMultiTexCoord1fARB
  void __stdcall GLee_Lazy_glMultiTexCoord1fARB(GLenum target, GLfloat s)  {if (GLeeInit()) glMultiTexCoord1fARB(target, s);}
  GLEEPFNGLMULTITEXCOORD1FARBPROC GLeeFuncPtr_glMultiTexCoord1fARB=GLee_Lazy_glMultiTexCoord1fARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1fvARB
#define GLEE_C_DEFINED_glMultiTexCoord1fvARB
  void __stdcall GLee_Lazy_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)  {if (GLeeInit()) glMultiTexCoord1fvARB(target, v);}
  GLEEPFNGLMULTITEXCOORD1FVARBPROC GLeeFuncPtr_glMultiTexCoord1fvARB=GLee_Lazy_glMultiTexCoord1fvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1iARB
#define GLEE_C_DEFINED_glMultiTexCoord1iARB
  void __stdcall GLee_Lazy_glMultiTexCoord1iARB(GLenum target, GLint s)  {if (GLeeInit()) glMultiTexCoord1iARB(target, s);}
  GLEEPFNGLMULTITEXCOORD1IARBPROC GLeeFuncPtr_glMultiTexCoord1iARB=GLee_Lazy_glMultiTexCoord1iARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1ivARB
#define GLEE_C_DEFINED_glMultiTexCoord1ivARB
  void __stdcall GLee_Lazy_glMultiTexCoord1ivARB(GLenum target, const GLint * v)  {if (GLeeInit()) glMultiTexCoord1ivARB(target, v);}
  GLEEPFNGLMULTITEXCOORD1IVARBPROC GLeeFuncPtr_glMultiTexCoord1ivARB=GLee_Lazy_glMultiTexCoord1ivARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1sARB
#define GLEE_C_DEFINED_glMultiTexCoord1sARB
  void __stdcall GLee_Lazy_glMultiTexCoord1sARB(GLenum target, GLshort s)  {if (GLeeInit()) glMultiTexCoord1sARB(target, s);}
  GLEEPFNGLMULTITEXCOORD1SARBPROC GLeeFuncPtr_glMultiTexCoord1sARB=GLee_Lazy_glMultiTexCoord1sARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1svARB
#define GLEE_C_DEFINED_glMultiTexCoord1svARB
  void __stdcall GLee_Lazy_glMultiTexCoord1svARB(GLenum target, const GLshort * v)  {if (GLeeInit()) glMultiTexCoord1svARB(target, v);}
  GLEEPFNGLMULTITEXCOORD1SVARBPROC GLeeFuncPtr_glMultiTexCoord1svARB=GLee_Lazy_glMultiTexCoord1svARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2dARB
#define GLEE_C_DEFINED_glMultiTexCoord2dARB
  void __stdcall GLee_Lazy_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)  {if (GLeeInit()) glMultiTexCoord2dARB(target, s, t);}
  GLEEPFNGLMULTITEXCOORD2DARBPROC GLeeFuncPtr_glMultiTexCoord2dARB=GLee_Lazy_glMultiTexCoord2dARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2dvARB
#define GLEE_C_DEFINED_glMultiTexCoord2dvARB
  void __stdcall GLee_Lazy_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)  {if (GLeeInit()) glMultiTexCoord2dvARB(target, v);}
  GLEEPFNGLMULTITEXCOORD2DVARBPROC GLeeFuncPtr_glMultiTexCoord2dvARB=GLee_Lazy_glMultiTexCoord2dvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2fARB
#define GLEE_C_DEFINED_glMultiTexCoord2fARB
  void __stdcall GLee_Lazy_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)  {if (GLeeInit()) glMultiTexCoord2fARB(target, s, t);}
  GLEEPFNGLMULTITEXCOORD2FARBPROC GLeeFuncPtr_glMultiTexCoord2fARB=GLee_Lazy_glMultiTexCoord2fARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2fvARB
#define GLEE_C_DEFINED_glMultiTexCoord2fvARB
  void __stdcall GLee_Lazy_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)  {if (GLeeInit()) glMultiTexCoord2fvARB(target, v);}
  GLEEPFNGLMULTITEXCOORD2FVARBPROC GLeeFuncPtr_glMultiTexCoord2fvARB=GLee_Lazy_glMultiTexCoord2fvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2iARB
#define GLEE_C_DEFINED_glMultiTexCoord2iARB
  void __stdcall GLee_Lazy_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)  {if (GLeeInit()) glMultiTexCoord2iARB(target, s, t);}
  GLEEPFNGLMULTITEXCOORD2IARBPROC GLeeFuncPtr_glMultiTexCoord2iARB=GLee_Lazy_glMultiTexCoord2iARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2ivARB
#define GLEE_C_DEFINED_glMultiTexCoord2ivARB
  void __stdcall GLee_Lazy_glMultiTexCoord2ivARB(GLenum target, const GLint * v)  {if (GLeeInit()) glMultiTexCoord2ivARB(target, v);}
  GLEEPFNGLMULTITEXCOORD2IVARBPROC GLeeFuncPtr_glMultiTexCoord2ivARB=GLee_Lazy_glMultiTexCoord2ivARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2sARB
#define GLEE_C_DEFINED_glMultiTexCoord2sARB
  void __stdcall GLee_Lazy_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)  {if (GLeeInit()) glMultiTexCoord2sARB(target, s, t);}
  GLEEPFNGLMULTITEXCOORD2SARBPROC GLeeFuncPtr_glMultiTexCoord2sARB=GLee_Lazy_glMultiTexCoord2sARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2svARB
#define GLEE_C_DEFINED_glMultiTexCoord2svARB
  void __stdcall GLee_Lazy_glMultiTexCoord2svARB(GLenum target, const GLshort * v)  {if (GLeeInit()) glMultiTexCoord2svARB(target, v);}
  GLEEPFNGLMULTITEXCOORD2SVARBPROC GLeeFuncPtr_glMultiTexCoord2svARB=GLee_Lazy_glMultiTexCoord2svARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3dARB
#define GLEE_C_DEFINED_glMultiTexCoord3dARB
  void __stdcall GLee_Lazy_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)  {if (GLeeInit()) glMultiTexCoord3dARB(target, s, t, r);}
  GLEEPFNGLMULTITEXCOORD3DARBPROC GLeeFuncPtr_glMultiTexCoord3dARB=GLee_Lazy_glMultiTexCoord3dARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3dvARB
#define GLEE_C_DEFINED_glMultiTexCoord3dvARB
  void __stdcall GLee_Lazy_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)  {if (GLeeInit()) glMultiTexCoord3dvARB(target, v);}
  GLEEPFNGLMULTITEXCOORD3DVARBPROC GLeeFuncPtr_glMultiTexCoord3dvARB=GLee_Lazy_glMultiTexCoord3dvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3fARB
#define GLEE_C_DEFINED_glMultiTexCoord3fARB
  void __stdcall GLee_Lazy_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)  {if (GLeeInit()) glMultiTexCoord3fARB(target, s, t, r);}
  GLEEPFNGLMULTITEXCOORD3FARBPROC GLeeFuncPtr_glMultiTexCoord3fARB=GLee_Lazy_glMultiTexCoord3fARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3fvARB
#define GLEE_C_DEFINED_glMultiTexCoord3fvARB
  void __stdcall GLee_Lazy_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)  {if (GLeeInit()) glMultiTexCoord3fvARB(target, v);}
  GLEEPFNGLMULTITEXCOORD3FVARBPROC GLeeFuncPtr_glMultiTexCoord3fvARB=GLee_Lazy_glMultiTexCoord3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3iARB
#define GLEE_C_DEFINED_glMultiTexCoord3iARB
  void __stdcall GLee_Lazy_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)  {if (GLeeInit()) glMultiTexCoord3iARB(target, s, t, r);}
  GLEEPFNGLMULTITEXCOORD3IARBPROC GLeeFuncPtr_glMultiTexCoord3iARB=GLee_Lazy_glMultiTexCoord3iARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3ivARB
#define GLEE_C_DEFINED_glMultiTexCoord3ivARB
  void __stdcall GLee_Lazy_glMultiTexCoord3ivARB(GLenum target, const GLint * v)  {if (GLeeInit()) glMultiTexCoord3ivARB(target, v);}
  GLEEPFNGLMULTITEXCOORD3IVARBPROC GLeeFuncPtr_glMultiTexCoord3ivARB=GLee_Lazy_glMultiTexCoord3ivARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3sARB
#define GLEE_C_DEFINED_glMultiTexCoord3sARB
  void __stdcall GLee_Lazy_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)  {if (GLeeInit()) glMultiTexCoord3sARB(target, s, t, r);}
  GLEEPFNGLMULTITEXCOORD3SARBPROC GLeeFuncPtr_glMultiTexCoord3sARB=GLee_Lazy_glMultiTexCoord3sARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3svARB
#define GLEE_C_DEFINED_glMultiTexCoord3svARB
  void __stdcall GLee_Lazy_glMultiTexCoord3svARB(GLenum target, const GLshort * v)  {if (GLeeInit()) glMultiTexCoord3svARB(target, v);}
  GLEEPFNGLMULTITEXCOORD3SVARBPROC GLeeFuncPtr_glMultiTexCoord3svARB=GLee_Lazy_glMultiTexCoord3svARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4dARB
#define GLEE_C_DEFINED_glMultiTexCoord4dARB
  void __stdcall GLee_Lazy_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)  {if (GLeeInit()) glMultiTexCoord4dARB(target, s, t, r, q);}
  GLEEPFNGLMULTITEXCOORD4DARBPROC GLeeFuncPtr_glMultiTexCoord4dARB=GLee_Lazy_glMultiTexCoord4dARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4dvARB
#define GLEE_C_DEFINED_glMultiTexCoord4dvARB
  void __stdcall GLee_Lazy_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)  {if (GLeeInit()) glMultiTexCoord4dvARB(target, v);}
  GLEEPFNGLMULTITEXCOORD4DVARBPROC GLeeFuncPtr_glMultiTexCoord4dvARB=GLee_Lazy_glMultiTexCoord4dvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4fARB
#define GLEE_C_DEFINED_glMultiTexCoord4fARB
  void __stdcall GLee_Lazy_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)  {if (GLeeInit()) glMultiTexCoord4fARB(target, s, t, r, q);}
  GLEEPFNGLMULTITEXCOORD4FARBPROC GLeeFuncPtr_glMultiTexCoord4fARB=GLee_Lazy_glMultiTexCoord4fARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4fvARB
#define GLEE_C_DEFINED_glMultiTexCoord4fvARB
  void __stdcall GLee_Lazy_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)  {if (GLeeInit()) glMultiTexCoord4fvARB(target, v);}
  GLEEPFNGLMULTITEXCOORD4FVARBPROC GLeeFuncPtr_glMultiTexCoord4fvARB=GLee_Lazy_glMultiTexCoord4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4iARB
#define GLEE_C_DEFINED_glMultiTexCoord4iARB
  void __stdcall GLee_Lazy_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)  {if (GLeeInit()) glMultiTexCoord4iARB(target, s, t, r, q);}
  GLEEPFNGLMULTITEXCOORD4IARBPROC GLeeFuncPtr_glMultiTexCoord4iARB=GLee_Lazy_glMultiTexCoord4iARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4ivARB
#define GLEE_C_DEFINED_glMultiTexCoord4ivARB
  void __stdcall GLee_Lazy_glMultiTexCoord4ivARB(GLenum target, const GLint * v)  {if (GLeeInit()) glMultiTexCoord4ivARB(target, v);}
  GLEEPFNGLMULTITEXCOORD4IVARBPROC GLeeFuncPtr_glMultiTexCoord4ivARB=GLee_Lazy_glMultiTexCoord4ivARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4sARB
#define GLEE_C_DEFINED_glMultiTexCoord4sARB
  void __stdcall GLee_Lazy_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)  {if (GLeeInit()) glMultiTexCoord4sARB(target, s, t, r, q);}
  GLEEPFNGLMULTITEXCOORD4SARBPROC GLeeFuncPtr_glMultiTexCoord4sARB=GLee_Lazy_glMultiTexCoord4sARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4svARB
#define GLEE_C_DEFINED_glMultiTexCoord4svARB
  void __stdcall GLee_Lazy_glMultiTexCoord4svARB(GLenum target, const GLshort * v)  {if (GLeeInit()) glMultiTexCoord4svARB(target, v);}
  GLEEPFNGLMULTITEXCOORD4SVARBPROC GLeeFuncPtr_glMultiTexCoord4svARB=GLee_Lazy_glMultiTexCoord4svARB;
#endif
#endif

/* GL_ARB_transpose_matrix */

#ifdef __GLEE_GL_ARB_transpose_matrix
#ifndef GLEE_C_DEFINED_glLoadTransposeMatrixfARB
#define GLEE_C_DEFINED_glLoadTransposeMatrixfARB
  void __stdcall GLee_Lazy_glLoadTransposeMatrixfARB(const GLfloat * m)  {if (GLeeInit()) glLoadTransposeMatrixfARB(m);}
  GLEEPFNGLLOADTRANSPOSEMATRIXFARBPROC GLeeFuncPtr_glLoadTransposeMatrixfARB=GLee_Lazy_glLoadTransposeMatrixfARB;
#endif
#ifndef GLEE_C_DEFINED_glLoadTransposeMatrixdARB
#define GLEE_C_DEFINED_glLoadTransposeMatrixdARB
  void __stdcall GLee_Lazy_glLoadTransposeMatrixdARB(const GLdouble * m)  {if (GLeeInit()) glLoadTransposeMatrixdARB(m);}
  GLEEPFNGLLOADTRANSPOSEMATRIXDARBPROC GLeeFuncPtr_glLoadTransposeMatrixdARB=GLee_Lazy_glLoadTransposeMatrixdARB;
#endif
#ifndef GLEE_C_DEFINED_glMultTransposeMatrixfARB
#define GLEE_C_DEFINED_glMultTransposeMatrixfARB
  void __stdcall GLee_Lazy_glMultTransposeMatrixfARB(const GLfloat * m)  {if (GLeeInit()) glMultTransposeMatrixfARB(m);}
  GLEEPFNGLMULTTRANSPOSEMATRIXFARBPROC GLeeFuncPtr_glMultTransposeMatrixfARB=GLee_Lazy_glMultTransposeMatrixfARB;
#endif
#ifndef GLEE_C_DEFINED_glMultTransposeMatrixdARB
#define GLEE_C_DEFINED_glMultTransposeMatrixdARB
  void __stdcall GLee_Lazy_glMultTransposeMatrixdARB(const GLdouble * m)  {if (GLeeInit()) glMultTransposeMatrixdARB(m);}
  GLEEPFNGLMULTTRANSPOSEMATRIXDARBPROC GLeeFuncPtr_glMultTransposeMatrixdARB=GLee_Lazy_glMultTransposeMatrixdARB;
#endif
#endif

/* GL_ARB_multisample */

#ifdef __GLEE_GL_ARB_multisample
#ifndef GLEE_C_DEFINED_glSampleCoverageARB
#define GLEE_C_DEFINED_glSampleCoverageARB
  void __stdcall GLee_Lazy_glSampleCoverageARB(GLclampf value, GLboolean invert)  {if (GLeeInit()) glSampleCoverageARB(value, invert);}
  GLEEPFNGLSAMPLECOVERAGEARBPROC GLeeFuncPtr_glSampleCoverageARB=GLee_Lazy_glSampleCoverageARB;
#endif
#endif

/* GL_ARB_texture_env_add */

#ifdef __GLEE_GL_ARB_texture_env_add
#endif

/* GL_ARB_texture_cube_map */

#ifdef __GLEE_GL_ARB_texture_cube_map
#endif

/* GL_ARB_texture_compression */

#ifdef __GLEE_GL_ARB_texture_compression
#ifndef GLEE_C_DEFINED_glCompressedTexImage3DARB
#define GLEE_C_DEFINED_glCompressedTexImage3DARB
  void __stdcall GLee_Lazy_glCompressedTexImage3DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data)  {if (GLeeInit()) glCompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imageSize, data);}
  GLEEPFNGLCOMPRESSEDTEXIMAGE3DARBPROC GLeeFuncPtr_glCompressedTexImage3DARB=GLee_Lazy_glCompressedTexImage3DARB;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage2DARB
#define GLEE_C_DEFINED_glCompressedTexImage2DARB
  void __stdcall GLee_Lazy_glCompressedTexImage2DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data)  {if (GLeeInit()) glCompressedTexImage2DARB(target, level, internalformat, width, height, border, imageSize, data);}
  GLEEPFNGLCOMPRESSEDTEXIMAGE2DARBPROC GLeeFuncPtr_glCompressedTexImage2DARB=GLee_Lazy_glCompressedTexImage2DARB;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage1DARB
#define GLEE_C_DEFINED_glCompressedTexImage1DARB
  void __stdcall GLee_Lazy_glCompressedTexImage1DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data)  {if (GLeeInit()) glCompressedTexImage1DARB(target, level, internalformat, width, border, imageSize, data);}
  GLEEPFNGLCOMPRESSEDTEXIMAGE1DARBPROC GLeeFuncPtr_glCompressedTexImage1DARB=GLee_Lazy_glCompressedTexImage1DARB;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage3DARB
#define GLEE_C_DEFINED_glCompressedTexSubImage3DARB
  void __stdcall GLee_Lazy_glCompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data)  {if (GLeeInit()) glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);}
  GLEEPFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC GLeeFuncPtr_glCompressedTexSubImage3DARB=GLee_Lazy_glCompressedTexSubImage3DARB;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage2DARB
#define GLEE_C_DEFINED_glCompressedTexSubImage2DARB
  void __stdcall GLee_Lazy_glCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data)  {if (GLeeInit()) glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, data);}
  GLEEPFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC GLeeFuncPtr_glCompressedTexSubImage2DARB=GLee_Lazy_glCompressedTexSubImage2DARB;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage1DARB
#define GLEE_C_DEFINED_glCompressedTexSubImage1DARB
  void __stdcall GLee_Lazy_glCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data)  {if (GLeeInit()) glCompressedTexSubImage1DARB(target, level, xoffset, width, format, imageSize, data);}
  GLEEPFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC GLeeFuncPtr_glCompressedTexSubImage1DARB=GLee_Lazy_glCompressedTexSubImage1DARB;
#endif
#ifndef GLEE_C_DEFINED_glGetCompressedTexImageARB
#define GLEE_C_DEFINED_glGetCompressedTexImageARB
  void __stdcall GLee_Lazy_glGetCompressedTexImageARB(GLenum target, GLint level, GLvoid * img)  {if (GLeeInit()) glGetCompressedTexImageARB(target, level, img);}
  GLEEPFNGLGETCOMPRESSEDTEXIMAGEARBPROC GLeeFuncPtr_glGetCompressedTexImageARB=GLee_Lazy_glGetCompressedTexImageARB;
#endif
#endif

/* GL_ARB_texture_border_clamp */

#ifdef __GLEE_GL_ARB_texture_border_clamp
#endif

/* GL_ARB_point_parameters */

#ifdef __GLEE_GL_ARB_point_parameters
#ifndef GLEE_C_DEFINED_glPointParameterfARB
#define GLEE_C_DEFINED_glPointParameterfARB
  void __stdcall GLee_Lazy_glPointParameterfARB(GLenum pname, GLfloat param)  {if (GLeeInit()) glPointParameterfARB(pname, param);}
  GLEEPFNGLPOINTPARAMETERFARBPROC GLeeFuncPtr_glPointParameterfARB=GLee_Lazy_glPointParameterfARB;
#endif
#ifndef GLEE_C_DEFINED_glPointParameterfvARB
#define GLEE_C_DEFINED_glPointParameterfvARB
  void __stdcall GLee_Lazy_glPointParameterfvARB(GLenum pname, const GLfloat * params)  {if (GLeeInit()) glPointParameterfvARB(pname, params);}
  GLEEPFNGLPOINTPARAMETERFVARBPROC GLeeFuncPtr_glPointParameterfvARB=GLee_Lazy_glPointParameterfvARB;
#endif
#endif

/* GL_ARB_vertex_blend */

#ifdef __GLEE_GL_ARB_vertex_blend
#ifndef GLEE_C_DEFINED_glWeightbvARB
#define GLEE_C_DEFINED_glWeightbvARB
  void __stdcall GLee_Lazy_glWeightbvARB(GLint size, const GLbyte * weights)  {if (GLeeInit()) glWeightbvARB(size, weights);}
  GLEEPFNGLWEIGHTBVARBPROC GLeeFuncPtr_glWeightbvARB=GLee_Lazy_glWeightbvARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightsvARB
#define GLEE_C_DEFINED_glWeightsvARB
  void __stdcall GLee_Lazy_glWeightsvARB(GLint size, const GLshort * weights)  {if (GLeeInit()) glWeightsvARB(size, weights);}
  GLEEPFNGLWEIGHTSVARBPROC GLeeFuncPtr_glWeightsvARB=GLee_Lazy_glWeightsvARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightivARB
#define GLEE_C_DEFINED_glWeightivARB
  void __stdcall GLee_Lazy_glWeightivARB(GLint size, const GLint * weights)  {if (GLeeInit()) glWeightivARB(size, weights);}
  GLEEPFNGLWEIGHTIVARBPROC GLeeFuncPtr_glWeightivARB=GLee_Lazy_glWeightivARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightfvARB
#define GLEE_C_DEFINED_glWeightfvARB
  void __stdcall GLee_Lazy_glWeightfvARB(GLint size, const GLfloat * weights)  {if (GLeeInit()) glWeightfvARB(size, weights);}
  GLEEPFNGLWEIGHTFVARBPROC GLeeFuncPtr_glWeightfvARB=GLee_Lazy_glWeightfvARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightdvARB
#define GLEE_C_DEFINED_glWeightdvARB
  void __stdcall GLee_Lazy_glWeightdvARB(GLint size, const GLdouble * weights)  {if (GLeeInit()) glWeightdvARB(size, weights);}
  GLEEPFNGLWEIGHTDVARBPROC GLeeFuncPtr_glWeightdvARB=GLee_Lazy_glWeightdvARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightubvARB
#define GLEE_C_DEFINED_glWeightubvARB
  void __stdcall GLee_Lazy_glWeightubvARB(GLint size, const GLubyte * weights)  {if (GLeeInit()) glWeightubvARB(size, weights);}
  GLEEPFNGLWEIGHTUBVARBPROC GLeeFuncPtr_glWeightubvARB=GLee_Lazy_glWeightubvARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightusvARB
#define GLEE_C_DEFINED_glWeightusvARB
  void __stdcall GLee_Lazy_glWeightusvARB(GLint size, const GLushort * weights)  {if (GLeeInit()) glWeightusvARB(size, weights);}
  GLEEPFNGLWEIGHTUSVARBPROC GLeeFuncPtr_glWeightusvARB=GLee_Lazy_glWeightusvARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightuivARB
#define GLEE_C_DEFINED_glWeightuivARB
  void __stdcall GLee_Lazy_glWeightuivARB(GLint size, const GLuint * weights)  {if (GLeeInit()) glWeightuivARB(size, weights);}
  GLEEPFNGLWEIGHTUIVARBPROC GLeeFuncPtr_glWeightuivARB=GLee_Lazy_glWeightuivARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightPointerARB
#define GLEE_C_DEFINED_glWeightPointerARB
  void __stdcall GLee_Lazy_glWeightPointerARB(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glWeightPointerARB(size, type, stride, pointer);}
  GLEEPFNGLWEIGHTPOINTERARBPROC GLeeFuncPtr_glWeightPointerARB=GLee_Lazy_glWeightPointerARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexBlendARB
#define GLEE_C_DEFINED_glVertexBlendARB
  void __stdcall GLee_Lazy_glVertexBlendARB(GLint count)  {if (GLeeInit()) glVertexBlendARB(count);}
  GLEEPFNGLVERTEXBLENDARBPROC GLeeFuncPtr_glVertexBlendARB=GLee_Lazy_glVertexBlendARB;
#endif
#endif

/* GL_ARB_matrix_palette */

#ifdef __GLEE_GL_ARB_matrix_palette
#ifndef GLEE_C_DEFINED_glCurrentPaletteMatrixARB
#define GLEE_C_DEFINED_glCurrentPaletteMatrixARB
  void __stdcall GLee_Lazy_glCurrentPaletteMatrixARB(GLint index)  {if (GLeeInit()) glCurrentPaletteMatrixARB(index);}
  GLEEPFNGLCURRENTPALETTEMATRIXARBPROC GLeeFuncPtr_glCurrentPaletteMatrixARB=GLee_Lazy_glCurrentPaletteMatrixARB;
#endif
#ifndef GLEE_C_DEFINED_glMatrixIndexubvARB
#define GLEE_C_DEFINED_glMatrixIndexubvARB
  void __stdcall GLee_Lazy_glMatrixIndexubvARB(GLint size, const GLubyte * indices)  {if (GLeeInit()) glMatrixIndexubvARB(size, indices);}
  GLEEPFNGLMATRIXINDEXUBVARBPROC GLeeFuncPtr_glMatrixIndexubvARB=GLee_Lazy_glMatrixIndexubvARB;
#endif
#ifndef GLEE_C_DEFINED_glMatrixIndexusvARB
#define GLEE_C_DEFINED_glMatrixIndexusvARB
  void __stdcall GLee_Lazy_glMatrixIndexusvARB(GLint size, const GLushort * indices)  {if (GLeeInit()) glMatrixIndexusvARB(size, indices);}
  GLEEPFNGLMATRIXINDEXUSVARBPROC GLeeFuncPtr_glMatrixIndexusvARB=GLee_Lazy_glMatrixIndexusvARB;
#endif
#ifndef GLEE_C_DEFINED_glMatrixIndexuivARB
#define GLEE_C_DEFINED_glMatrixIndexuivARB
  void __stdcall GLee_Lazy_glMatrixIndexuivARB(GLint size, const GLuint * indices)  {if (GLeeInit()) glMatrixIndexuivARB(size, indices);}
  GLEEPFNGLMATRIXINDEXUIVARBPROC GLeeFuncPtr_glMatrixIndexuivARB=GLee_Lazy_glMatrixIndexuivARB;
#endif
#ifndef GLEE_C_DEFINED_glMatrixIndexPointerARB
#define GLEE_C_DEFINED_glMatrixIndexPointerARB
  void __stdcall GLee_Lazy_glMatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glMatrixIndexPointerARB(size, type, stride, pointer);}
  GLEEPFNGLMATRIXINDEXPOINTERARBPROC GLeeFuncPtr_glMatrixIndexPointerARB=GLee_Lazy_glMatrixIndexPointerARB;
#endif
#endif

/* GL_ARB_texture_env_combine */

#ifdef __GLEE_GL_ARB_texture_env_combine
#endif

/* GL_ARB_texture_env_crossbar */

#ifdef __GLEE_GL_ARB_texture_env_crossbar
#endif

/* GL_ARB_texture_env_dot3 */

#ifdef __GLEE_GL_ARB_texture_env_dot3
#endif

/* GL_ARB_texture_mirrored_repeat */

#ifdef __GLEE_GL_ARB_texture_mirrored_repeat
#endif

/* GL_ARB_depth_texture */

#ifdef __GLEE_GL_ARB_depth_texture
#endif

/* GL_ARB_shadow */

#ifdef __GLEE_GL_ARB_shadow
#endif

/* GL_ARB_shadow_ambient */

#ifdef __GLEE_GL_ARB_shadow_ambient
#endif

/* GL_ARB_window_pos */

#ifdef __GLEE_GL_ARB_window_pos
#ifndef GLEE_C_DEFINED_glWindowPos2dARB
#define GLEE_C_DEFINED_glWindowPos2dARB
  void __stdcall GLee_Lazy_glWindowPos2dARB(GLdouble x, GLdouble y)  {if (GLeeInit()) glWindowPos2dARB(x, y);}
  GLEEPFNGLWINDOWPOS2DARBPROC GLeeFuncPtr_glWindowPos2dARB=GLee_Lazy_glWindowPos2dARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2dvARB
#define GLEE_C_DEFINED_glWindowPos2dvARB
  void __stdcall GLee_Lazy_glWindowPos2dvARB(const GLdouble * v)  {if (GLeeInit()) glWindowPos2dvARB(v);}
  GLEEPFNGLWINDOWPOS2DVARBPROC GLeeFuncPtr_glWindowPos2dvARB=GLee_Lazy_glWindowPos2dvARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2fARB
#define GLEE_C_DEFINED_glWindowPos2fARB
  void __stdcall GLee_Lazy_glWindowPos2fARB(GLfloat x, GLfloat y)  {if (GLeeInit()) glWindowPos2fARB(x, y);}
  GLEEPFNGLWINDOWPOS2FARBPROC GLeeFuncPtr_glWindowPos2fARB=GLee_Lazy_glWindowPos2fARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2fvARB
#define GLEE_C_DEFINED_glWindowPos2fvARB
  void __stdcall GLee_Lazy_glWindowPos2fvARB(const GLfloat * v)  {if (GLeeInit()) glWindowPos2fvARB(v);}
  GLEEPFNGLWINDOWPOS2FVARBPROC GLeeFuncPtr_glWindowPos2fvARB=GLee_Lazy_glWindowPos2fvARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2iARB
#define GLEE_C_DEFINED_glWindowPos2iARB
  void __stdcall GLee_Lazy_glWindowPos2iARB(GLint x, GLint y)  {if (GLeeInit()) glWindowPos2iARB(x, y);}
  GLEEPFNGLWINDOWPOS2IARBPROC GLeeFuncPtr_glWindowPos2iARB=GLee_Lazy_glWindowPos2iARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2ivARB
#define GLEE_C_DEFINED_glWindowPos2ivARB
  void __stdcall GLee_Lazy_glWindowPos2ivARB(const GLint * v)  {if (GLeeInit()) glWindowPos2ivARB(v);}
  GLEEPFNGLWINDOWPOS2IVARBPROC GLeeFuncPtr_glWindowPos2ivARB=GLee_Lazy_glWindowPos2ivARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2sARB
#define GLEE_C_DEFINED_glWindowPos2sARB
  void __stdcall GLee_Lazy_glWindowPos2sARB(GLshort x, GLshort y)  {if (GLeeInit()) glWindowPos2sARB(x, y);}
  GLEEPFNGLWINDOWPOS2SARBPROC GLeeFuncPtr_glWindowPos2sARB=GLee_Lazy_glWindowPos2sARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2svARB
#define GLEE_C_DEFINED_glWindowPos2svARB
  void __stdcall GLee_Lazy_glWindowPos2svARB(const GLshort * v)  {if (GLeeInit()) glWindowPos2svARB(v);}
  GLEEPFNGLWINDOWPOS2SVARBPROC GLeeFuncPtr_glWindowPos2svARB=GLee_Lazy_glWindowPos2svARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3dARB
#define GLEE_C_DEFINED_glWindowPos3dARB
  void __stdcall GLee_Lazy_glWindowPos3dARB(GLdouble x, GLdouble y, GLdouble z)  {if (GLeeInit()) glWindowPos3dARB(x, y, z);}
  GLEEPFNGLWINDOWPOS3DARBPROC GLeeFuncPtr_glWindowPos3dARB=GLee_Lazy_glWindowPos3dARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3dvARB
#define GLEE_C_DEFINED_glWindowPos3dvARB
  void __stdcall GLee_Lazy_glWindowPos3dvARB(const GLdouble * v)  {if (GLeeInit()) glWindowPos3dvARB(v);}
  GLEEPFNGLWINDOWPOS3DVARBPROC GLeeFuncPtr_glWindowPos3dvARB=GLee_Lazy_glWindowPos3dvARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3fARB
#define GLEE_C_DEFINED_glWindowPos3fARB
  void __stdcall GLee_Lazy_glWindowPos3fARB(GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glWindowPos3fARB(x, y, z);}
  GLEEPFNGLWINDOWPOS3FARBPROC GLeeFuncPtr_glWindowPos3fARB=GLee_Lazy_glWindowPos3fARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3fvARB
#define GLEE_C_DEFINED_glWindowPos3fvARB
  void __stdcall GLee_Lazy_glWindowPos3fvARB(const GLfloat * v)  {if (GLeeInit()) glWindowPos3fvARB(v);}
  GLEEPFNGLWINDOWPOS3FVARBPROC GLeeFuncPtr_glWindowPos3fvARB=GLee_Lazy_glWindowPos3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3iARB
#define GLEE_C_DEFINED_glWindowPos3iARB
  void __stdcall GLee_Lazy_glWindowPos3iARB(GLint x, GLint y, GLint z)  {if (GLeeInit()) glWindowPos3iARB(x, y, z);}
  GLEEPFNGLWINDOWPOS3IARBPROC GLeeFuncPtr_glWindowPos3iARB=GLee_Lazy_glWindowPos3iARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3ivARB
#define GLEE_C_DEFINED_glWindowPos3ivARB
  void __stdcall GLee_Lazy_glWindowPos3ivARB(const GLint * v)  {if (GLeeInit()) glWindowPos3ivARB(v);}
  GLEEPFNGLWINDOWPOS3IVARBPROC GLeeFuncPtr_glWindowPos3ivARB=GLee_Lazy_glWindowPos3ivARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3sARB
#define GLEE_C_DEFINED_glWindowPos3sARB
  void __stdcall GLee_Lazy_glWindowPos3sARB(GLshort x, GLshort y, GLshort z)  {if (GLeeInit()) glWindowPos3sARB(x, y, z);}
  GLEEPFNGLWINDOWPOS3SARBPROC GLeeFuncPtr_glWindowPos3sARB=GLee_Lazy_glWindowPos3sARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3svARB
#define GLEE_C_DEFINED_glWindowPos3svARB
  void __stdcall GLee_Lazy_glWindowPos3svARB(const GLshort * v)  {if (GLeeInit()) glWindowPos3svARB(v);}
  GLEEPFNGLWINDOWPOS3SVARBPROC GLeeFuncPtr_glWindowPos3svARB=GLee_Lazy_glWindowPos3svARB;
#endif
#endif

/* GL_ARB_vertex_program */

#ifdef __GLEE_GL_ARB_vertex_program
#ifndef GLEE_C_DEFINED_glVertexAttrib1dARB
#define GLEE_C_DEFINED_glVertexAttrib1dARB
  void __stdcall GLee_Lazy_glVertexAttrib1dARB(GLuint index, GLdouble x)  {if (GLeeInit()) glVertexAttrib1dARB(index, x);}
  GLEEPFNGLVERTEXATTRIB1DARBPROC GLeeFuncPtr_glVertexAttrib1dARB=GLee_Lazy_glVertexAttrib1dARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1dvARB
#define GLEE_C_DEFINED_glVertexAttrib1dvARB
  void __stdcall GLee_Lazy_glVertexAttrib1dvARB(GLuint index, const GLdouble * v)  {if (GLeeInit()) glVertexAttrib1dvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB1DVARBPROC GLeeFuncPtr_glVertexAttrib1dvARB=GLee_Lazy_glVertexAttrib1dvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1fARB
#define GLEE_C_DEFINED_glVertexAttrib1fARB
  void __stdcall GLee_Lazy_glVertexAttrib1fARB(GLuint index, GLfloat x)  {if (GLeeInit()) glVertexAttrib1fARB(index, x);}
  GLEEPFNGLVERTEXATTRIB1FARBPROC GLeeFuncPtr_glVertexAttrib1fARB=GLee_Lazy_glVertexAttrib1fARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1fvARB
#define GLEE_C_DEFINED_glVertexAttrib1fvARB
  void __stdcall GLee_Lazy_glVertexAttrib1fvARB(GLuint index, const GLfloat * v)  {if (GLeeInit()) glVertexAttrib1fvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB1FVARBPROC GLeeFuncPtr_glVertexAttrib1fvARB=GLee_Lazy_glVertexAttrib1fvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1sARB
#define GLEE_C_DEFINED_glVertexAttrib1sARB
  void __stdcall GLee_Lazy_glVertexAttrib1sARB(GLuint index, GLshort x)  {if (GLeeInit()) glVertexAttrib1sARB(index, x);}
  GLEEPFNGLVERTEXATTRIB1SARBPROC GLeeFuncPtr_glVertexAttrib1sARB=GLee_Lazy_glVertexAttrib1sARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1svARB
#define GLEE_C_DEFINED_glVertexAttrib1svARB
  void __stdcall GLee_Lazy_glVertexAttrib1svARB(GLuint index, const GLshort * v)  {if (GLeeInit()) glVertexAttrib1svARB(index, v);}
  GLEEPFNGLVERTEXATTRIB1SVARBPROC GLeeFuncPtr_glVertexAttrib1svARB=GLee_Lazy_glVertexAttrib1svARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2dARB
#define GLEE_C_DEFINED_glVertexAttrib2dARB
  void __stdcall GLee_Lazy_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)  {if (GLeeInit()) glVertexAttrib2dARB(index, x, y);}
  GLEEPFNGLVERTEXATTRIB2DARBPROC GLeeFuncPtr_glVertexAttrib2dARB=GLee_Lazy_glVertexAttrib2dARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2dvARB
#define GLEE_C_DEFINED_glVertexAttrib2dvARB
  void __stdcall GLee_Lazy_glVertexAttrib2dvARB(GLuint index, const GLdouble * v)  {if (GLeeInit()) glVertexAttrib2dvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB2DVARBPROC GLeeFuncPtr_glVertexAttrib2dvARB=GLee_Lazy_glVertexAttrib2dvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2fARB
#define GLEE_C_DEFINED_glVertexAttrib2fARB
  void __stdcall GLee_Lazy_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)  {if (GLeeInit()) glVertexAttrib2fARB(index, x, y);}
  GLEEPFNGLVERTEXATTRIB2FARBPROC GLeeFuncPtr_glVertexAttrib2fARB=GLee_Lazy_glVertexAttrib2fARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2fvARB
#define GLEE_C_DEFINED_glVertexAttrib2fvARB
  void __stdcall GLee_Lazy_glVertexAttrib2fvARB(GLuint index, const GLfloat * v)  {if (GLeeInit()) glVertexAttrib2fvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB2FVARBPROC GLeeFuncPtr_glVertexAttrib2fvARB=GLee_Lazy_glVertexAttrib2fvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2sARB
#define GLEE_C_DEFINED_glVertexAttrib2sARB
  void __stdcall GLee_Lazy_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)  {if (GLeeInit()) glVertexAttrib2sARB(index, x, y);}
  GLEEPFNGLVERTEXATTRIB2SARBPROC GLeeFuncPtr_glVertexAttrib2sARB=GLee_Lazy_glVertexAttrib2sARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2svARB
#define GLEE_C_DEFINED_glVertexAttrib2svARB
  void __stdcall GLee_Lazy_glVertexAttrib2svARB(GLuint index, const GLshort * v)  {if (GLeeInit()) glVertexAttrib2svARB(index, v);}
  GLEEPFNGLVERTEXATTRIB2SVARBPROC GLeeFuncPtr_glVertexAttrib2svARB=GLee_Lazy_glVertexAttrib2svARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3dARB
#define GLEE_C_DEFINED_glVertexAttrib3dARB
  void __stdcall GLee_Lazy_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)  {if (GLeeInit()) glVertexAttrib3dARB(index, x, y, z);}
  GLEEPFNGLVERTEXATTRIB3DARBPROC GLeeFuncPtr_glVertexAttrib3dARB=GLee_Lazy_glVertexAttrib3dARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3dvARB
#define GLEE_C_DEFINED_glVertexAttrib3dvARB
  void __stdcall GLee_Lazy_glVertexAttrib3dvARB(GLuint index, const GLdouble * v)  {if (GLeeInit()) glVertexAttrib3dvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB3DVARBPROC GLeeFuncPtr_glVertexAttrib3dvARB=GLee_Lazy_glVertexAttrib3dvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3fARB
#define GLEE_C_DEFINED_glVertexAttrib3fARB
  void __stdcall GLee_Lazy_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glVertexAttrib3fARB(index, x, y, z);}
  GLEEPFNGLVERTEXATTRIB3FARBPROC GLeeFuncPtr_glVertexAttrib3fARB=GLee_Lazy_glVertexAttrib3fARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3fvARB
#define GLEE_C_DEFINED_glVertexAttrib3fvARB
  void __stdcall GLee_Lazy_glVertexAttrib3fvARB(GLuint index, const GLfloat * v)  {if (GLeeInit()) glVertexAttrib3fvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB3FVARBPROC GLeeFuncPtr_glVertexAttrib3fvARB=GLee_Lazy_glVertexAttrib3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3sARB
#define GLEE_C_DEFINED_glVertexAttrib3sARB
  void __stdcall GLee_Lazy_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)  {if (GLeeInit()) glVertexAttrib3sARB(index, x, y, z);}
  GLEEPFNGLVERTEXATTRIB3SARBPROC GLeeFuncPtr_glVertexAttrib3sARB=GLee_Lazy_glVertexAttrib3sARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3svARB
#define GLEE_C_DEFINED_glVertexAttrib3svARB
  void __stdcall GLee_Lazy_glVertexAttrib3svARB(GLuint index, const GLshort * v)  {if (GLeeInit()) glVertexAttrib3svARB(index, v);}
  GLEEPFNGLVERTEXATTRIB3SVARBPROC GLeeFuncPtr_glVertexAttrib3svARB=GLee_Lazy_glVertexAttrib3svARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NbvARB
#define GLEE_C_DEFINED_glVertexAttrib4NbvARB
  void __stdcall GLee_Lazy_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v)  {if (GLeeInit()) glVertexAttrib4NbvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4NBVARBPROC GLeeFuncPtr_glVertexAttrib4NbvARB=GLee_Lazy_glVertexAttrib4NbvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NivARB
#define GLEE_C_DEFINED_glVertexAttrib4NivARB
  void __stdcall GLee_Lazy_glVertexAttrib4NivARB(GLuint index, const GLint * v)  {if (GLeeInit()) glVertexAttrib4NivARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4NIVARBPROC GLeeFuncPtr_glVertexAttrib4NivARB=GLee_Lazy_glVertexAttrib4NivARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NsvARB
#define GLEE_C_DEFINED_glVertexAttrib4NsvARB
  void __stdcall GLee_Lazy_glVertexAttrib4NsvARB(GLuint index, const GLshort * v)  {if (GLeeInit()) glVertexAttrib4NsvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4NSVARBPROC GLeeFuncPtr_glVertexAttrib4NsvARB=GLee_Lazy_glVertexAttrib4NsvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NubARB
#define GLEE_C_DEFINED_glVertexAttrib4NubARB
  void __stdcall GLee_Lazy_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)  {if (GLeeInit()) glVertexAttrib4NubARB(index, x, y, z, w);}
  GLEEPFNGLVERTEXATTRIB4NUBARBPROC GLeeFuncPtr_glVertexAttrib4NubARB=GLee_Lazy_glVertexAttrib4NubARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NubvARB
#define GLEE_C_DEFINED_glVertexAttrib4NubvARB
  void __stdcall GLee_Lazy_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v)  {if (GLeeInit()) glVertexAttrib4NubvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4NUBVARBPROC GLeeFuncPtr_glVertexAttrib4NubvARB=GLee_Lazy_glVertexAttrib4NubvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NuivARB
#define GLEE_C_DEFINED_glVertexAttrib4NuivARB
  void __stdcall GLee_Lazy_glVertexAttrib4NuivARB(GLuint index, const GLuint * v)  {if (GLeeInit()) glVertexAttrib4NuivARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4NUIVARBPROC GLeeFuncPtr_glVertexAttrib4NuivARB=GLee_Lazy_glVertexAttrib4NuivARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NusvARB
#define GLEE_C_DEFINED_glVertexAttrib4NusvARB
  void __stdcall GLee_Lazy_glVertexAttrib4NusvARB(GLuint index, const GLushort * v)  {if (GLeeInit()) glVertexAttrib4NusvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4NUSVARBPROC GLeeFuncPtr_glVertexAttrib4NusvARB=GLee_Lazy_glVertexAttrib4NusvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4bvARB
#define GLEE_C_DEFINED_glVertexAttrib4bvARB
  void __stdcall GLee_Lazy_glVertexAttrib4bvARB(GLuint index, const GLbyte * v)  {if (GLeeInit()) glVertexAttrib4bvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4BVARBPROC GLeeFuncPtr_glVertexAttrib4bvARB=GLee_Lazy_glVertexAttrib4bvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4dARB
#define GLEE_C_DEFINED_glVertexAttrib4dARB
  void __stdcall GLee_Lazy_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)  {if (GLeeInit()) glVertexAttrib4dARB(index, x, y, z, w);}
  GLEEPFNGLVERTEXATTRIB4DARBPROC GLeeFuncPtr_glVertexAttrib4dARB=GLee_Lazy_glVertexAttrib4dARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4dvARB
#define GLEE_C_DEFINED_glVertexAttrib4dvARB
  void __stdcall GLee_Lazy_glVertexAttrib4dvARB(GLuint index, const GLdouble * v)  {if (GLeeInit()) glVertexAttrib4dvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4DVARBPROC GLeeFuncPtr_glVertexAttrib4dvARB=GLee_Lazy_glVertexAttrib4dvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4fARB
#define GLEE_C_DEFINED_glVertexAttrib4fARB
  void __stdcall GLee_Lazy_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)  {if (GLeeInit()) glVertexAttrib4fARB(index, x, y, z, w);}
  GLEEPFNGLVERTEXATTRIB4FARBPROC GLeeFuncPtr_glVertexAttrib4fARB=GLee_Lazy_glVertexAttrib4fARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4fvARB
#define GLEE_C_DEFINED_glVertexAttrib4fvARB
  void __stdcall GLee_Lazy_glVertexAttrib4fvARB(GLuint index, const GLfloat * v)  {if (GLeeInit()) glVertexAttrib4fvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4FVARBPROC GLeeFuncPtr_glVertexAttrib4fvARB=GLee_Lazy_glVertexAttrib4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4ivARB
#define GLEE_C_DEFINED_glVertexAttrib4ivARB
  void __stdcall GLee_Lazy_glVertexAttrib4ivARB(GLuint index, const GLint * v)  {if (GLeeInit()) glVertexAttrib4ivARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4IVARBPROC GLeeFuncPtr_glVertexAttrib4ivARB=GLee_Lazy_glVertexAttrib4ivARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4sARB
#define GLEE_C_DEFINED_glVertexAttrib4sARB
  void __stdcall GLee_Lazy_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)  {if (GLeeInit()) glVertexAttrib4sARB(index, x, y, z, w);}
  GLEEPFNGLVERTEXATTRIB4SARBPROC GLeeFuncPtr_glVertexAttrib4sARB=GLee_Lazy_glVertexAttrib4sARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4svARB
#define GLEE_C_DEFINED_glVertexAttrib4svARB
  void __stdcall GLee_Lazy_glVertexAttrib4svARB(GLuint index, const GLshort * v)  {if (GLeeInit()) glVertexAttrib4svARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4SVARBPROC GLeeFuncPtr_glVertexAttrib4svARB=GLee_Lazy_glVertexAttrib4svARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4ubvARB
#define GLEE_C_DEFINED_glVertexAttrib4ubvARB
  void __stdcall GLee_Lazy_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v)  {if (GLeeInit()) glVertexAttrib4ubvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4UBVARBPROC GLeeFuncPtr_glVertexAttrib4ubvARB=GLee_Lazy_glVertexAttrib4ubvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4uivARB
#define GLEE_C_DEFINED_glVertexAttrib4uivARB
  void __stdcall GLee_Lazy_glVertexAttrib4uivARB(GLuint index, const GLuint * v)  {if (GLeeInit()) glVertexAttrib4uivARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4UIVARBPROC GLeeFuncPtr_glVertexAttrib4uivARB=GLee_Lazy_glVertexAttrib4uivARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4usvARB
#define GLEE_C_DEFINED_glVertexAttrib4usvARB
  void __stdcall GLee_Lazy_glVertexAttrib4usvARB(GLuint index, const GLushort * v)  {if (GLeeInit()) glVertexAttrib4usvARB(index, v);}
  GLEEPFNGLVERTEXATTRIB4USVARBPROC GLeeFuncPtr_glVertexAttrib4usvARB=GLee_Lazy_glVertexAttrib4usvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribPointerARB
#define GLEE_C_DEFINED_glVertexAttribPointerARB
  void __stdcall GLee_Lazy_glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glVertexAttribPointerARB(index, size, type, normalized, stride, pointer);}
  GLEEPFNGLVERTEXATTRIBPOINTERARBPROC GLeeFuncPtr_glVertexAttribPointerARB=GLee_Lazy_glVertexAttribPointerARB;
#endif
#ifndef GLEE_C_DEFINED_glEnableVertexAttribArrayARB
#define GLEE_C_DEFINED_glEnableVertexAttribArrayARB
  void __stdcall GLee_Lazy_glEnableVertexAttribArrayARB(GLuint index)  {if (GLeeInit()) glEnableVertexAttribArrayARB(index);}
  GLEEPFNGLENABLEVERTEXATTRIBARRAYARBPROC GLeeFuncPtr_glEnableVertexAttribArrayARB=GLee_Lazy_glEnableVertexAttribArrayARB;
#endif
#ifndef GLEE_C_DEFINED_glDisableVertexAttribArrayARB
#define GLEE_C_DEFINED_glDisableVertexAttribArrayARB
  void __stdcall GLee_Lazy_glDisableVertexAttribArrayARB(GLuint index)  {if (GLeeInit()) glDisableVertexAttribArrayARB(index);}
  GLEEPFNGLDISABLEVERTEXATTRIBARRAYARBPROC GLeeFuncPtr_glDisableVertexAttribArrayARB=GLee_Lazy_glDisableVertexAttribArrayARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramStringARB
#define GLEE_C_DEFINED_glProgramStringARB
  void __stdcall GLee_Lazy_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string)  {if (GLeeInit()) glProgramStringARB(target, format, len, string);}
  GLEEPFNGLPROGRAMSTRINGARBPROC GLeeFuncPtr_glProgramStringARB=GLee_Lazy_glProgramStringARB;
#endif
#ifndef GLEE_C_DEFINED_glBindProgramARB
#define GLEE_C_DEFINED_glBindProgramARB
  void __stdcall GLee_Lazy_glBindProgramARB(GLenum target, GLuint program)  {if (GLeeInit()) glBindProgramARB(target, program);}
  GLEEPFNGLBINDPROGRAMARBPROC GLeeFuncPtr_glBindProgramARB=GLee_Lazy_glBindProgramARB;
#endif
#ifndef GLEE_C_DEFINED_glDeleteProgramsARB
#define GLEE_C_DEFINED_glDeleteProgramsARB
  void __stdcall GLee_Lazy_glDeleteProgramsARB(GLsizei n, const GLuint * programs)  {if (GLeeInit()) glDeleteProgramsARB(n, programs);}
  GLEEPFNGLDELETEPROGRAMSARBPROC GLeeFuncPtr_glDeleteProgramsARB=GLee_Lazy_glDeleteProgramsARB;
#endif
#ifndef GLEE_C_DEFINED_glGenProgramsARB
#define GLEE_C_DEFINED_glGenProgramsARB
  void __stdcall GLee_Lazy_glGenProgramsARB(GLsizei n, GLuint * programs)  {if (GLeeInit()) glGenProgramsARB(n, programs);}
  GLEEPFNGLGENPROGRAMSARBPROC GLeeFuncPtr_glGenProgramsARB=GLee_Lazy_glGenProgramsARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameter4dARB
#define GLEE_C_DEFINED_glProgramEnvParameter4dARB
  void __stdcall GLee_Lazy_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)  {if (GLeeInit()) glProgramEnvParameter4dARB(target, index, x, y, z, w);}
  GLEEPFNGLPROGRAMENVPARAMETER4DARBPROC GLeeFuncPtr_glProgramEnvParameter4dARB=GLee_Lazy_glProgramEnvParameter4dARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameter4dvARB
#define GLEE_C_DEFINED_glProgramEnvParameter4dvARB
  void __stdcall GLee_Lazy_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)  {if (GLeeInit()) glProgramEnvParameter4dvARB(target, index, params);}
  GLEEPFNGLPROGRAMENVPARAMETER4DVARBPROC GLeeFuncPtr_glProgramEnvParameter4dvARB=GLee_Lazy_glProgramEnvParameter4dvARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameter4fARB
#define GLEE_C_DEFINED_glProgramEnvParameter4fARB
  void __stdcall GLee_Lazy_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)  {if (GLeeInit()) glProgramEnvParameter4fARB(target, index, x, y, z, w);}
  GLEEPFNGLPROGRAMENVPARAMETER4FARBPROC GLeeFuncPtr_glProgramEnvParameter4fARB=GLee_Lazy_glProgramEnvParameter4fARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameter4fvARB
#define GLEE_C_DEFINED_glProgramEnvParameter4fvARB
  void __stdcall GLee_Lazy_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)  {if (GLeeInit()) glProgramEnvParameter4fvARB(target, index, params);}
  GLEEPFNGLPROGRAMENVPARAMETER4FVARBPROC GLeeFuncPtr_glProgramEnvParameter4fvARB=GLee_Lazy_glProgramEnvParameter4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameter4dARB
#define GLEE_C_DEFINED_glProgramLocalParameter4dARB
  void __stdcall GLee_Lazy_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)  {if (GLeeInit()) glProgramLocalParameter4dARB(target, index, x, y, z, w);}
  GLEEPFNGLPROGRAMLOCALPARAMETER4DARBPROC GLeeFuncPtr_glProgramLocalParameter4dARB=GLee_Lazy_glProgramLocalParameter4dARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameter4dvARB
#define GLEE_C_DEFINED_glProgramLocalParameter4dvARB
  void __stdcall GLee_Lazy_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)  {if (GLeeInit()) glProgramLocalParameter4dvARB(target, index, params);}
  GLEEPFNGLPROGRAMLOCALPARAMETER4DVARBPROC GLeeFuncPtr_glProgramLocalParameter4dvARB=GLee_Lazy_glProgramLocalParameter4dvARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameter4fARB
#define GLEE_C_DEFINED_glProgramLocalParameter4fARB
  void __stdcall GLee_Lazy_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)  {if (GLeeInit()) glProgramLocalParameter4fARB(target, index, x, y, z, w);}
  GLEEPFNGLPROGRAMLOCALPARAMETER4FARBPROC GLeeFuncPtr_glProgramLocalParameter4fARB=GLee_Lazy_glProgramLocalParameter4fARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameter4fvARB
#define GLEE_C_DEFINED_glProgramLocalParameter4fvARB
  void __stdcall GLee_Lazy_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)  {if (GLeeInit()) glProgramLocalParameter4fvARB(target, index, params);}
  GLEEPFNGLPROGRAMLOCALPARAMETER4FVARBPROC GLeeFuncPtr_glProgramLocalParameter4fvARB=GLee_Lazy_glProgramLocalParameter4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramEnvParameterdvARB
#define GLEE_C_DEFINED_glGetProgramEnvParameterdvARB
  void __stdcall GLee_Lazy_glGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble * params)  {if (GLeeInit()) glGetProgramEnvParameterdvARB(target, index, params);}
  GLEEPFNGLGETPROGRAMENVPARAMETERDVARBPROC GLeeFuncPtr_glGetProgramEnvParameterdvARB=GLee_Lazy_glGetProgramEnvParameterdvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramEnvParameterfvARB
#define GLEE_C_DEFINED_glGetProgramEnvParameterfvARB
  void __stdcall GLee_Lazy_glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat * params)  {if (GLeeInit()) glGetProgramEnvParameterfvARB(target, index, params);}
  GLEEPFNGLGETPROGRAMENVPARAMETERFVARBPROC GLeeFuncPtr_glGetProgramEnvParameterfvARB=GLee_Lazy_glGetProgramEnvParameterfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramLocalParameterdvARB
#define GLEE_C_DEFINED_glGetProgramLocalParameterdvARB
  void __stdcall GLee_Lazy_glGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble * params)  {if (GLeeInit()) glGetProgramLocalParameterdvARB(target, index, params);}
  GLEEPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC GLeeFuncPtr_glGetProgramLocalParameterdvARB=GLee_Lazy_glGetProgramLocalParameterdvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramLocalParameterfvARB
#define GLEE_C_DEFINED_glGetProgramLocalParameterfvARB
  void __stdcall GLee_Lazy_glGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat * params)  {if (GLeeInit()) glGetProgramLocalParameterfvARB(target, index, params);}
  GLEEPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC GLeeFuncPtr_glGetProgramLocalParameterfvARB=GLee_Lazy_glGetProgramLocalParameterfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramivARB
#define GLEE_C_DEFINED_glGetProgramivARB
  void __stdcall GLee_Lazy_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetProgramivARB(target, pname, params);}
  GLEEPFNGLGETPROGRAMIVARBPROC GLeeFuncPtr_glGetProgramivARB=GLee_Lazy_glGetProgramivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramStringARB
#define GLEE_C_DEFINED_glGetProgramStringARB
  void __stdcall GLee_Lazy_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)  {if (GLeeInit()) glGetProgramStringARB(target, pname, string);}
  GLEEPFNGLGETPROGRAMSTRINGARBPROC GLeeFuncPtr_glGetProgramStringARB=GLee_Lazy_glGetProgramStringARB;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribdvARB
#define GLEE_C_DEFINED_glGetVertexAttribdvARB
  void __stdcall GLee_Lazy_glGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble * params)  {if (GLeeInit()) glGetVertexAttribdvARB(index, pname, params);}
  GLEEPFNGLGETVERTEXATTRIBDVARBPROC GLeeFuncPtr_glGetVertexAttribdvARB=GLee_Lazy_glGetVertexAttribdvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribfvARB
#define GLEE_C_DEFINED_glGetVertexAttribfvARB
  void __stdcall GLee_Lazy_glGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetVertexAttribfvARB(index, pname, params);}
  GLEEPFNGLGETVERTEXATTRIBFVARBPROC GLeeFuncPtr_glGetVertexAttribfvARB=GLee_Lazy_glGetVertexAttribfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribivARB
#define GLEE_C_DEFINED_glGetVertexAttribivARB
  void __stdcall GLee_Lazy_glGetVertexAttribivARB(GLuint index, GLenum pname, GLint * params)  {if (GLeeInit()) glGetVertexAttribivARB(index, pname, params);}
  GLEEPFNGLGETVERTEXATTRIBIVARBPROC GLeeFuncPtr_glGetVertexAttribivARB=GLee_Lazy_glGetVertexAttribivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribPointervARB
#define GLEE_C_DEFINED_glGetVertexAttribPointervARB
  void __stdcall GLee_Lazy_glGetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid* * pointer)  {if (GLeeInit()) glGetVertexAttribPointervARB(index, pname, pointer);}
  GLEEPFNGLGETVERTEXATTRIBPOINTERVARBPROC GLeeFuncPtr_glGetVertexAttribPointervARB=GLee_Lazy_glGetVertexAttribPointervARB;
#endif
#ifndef GLEE_C_DEFINED_glIsProgramARB
#define GLEE_C_DEFINED_glIsProgramARB
  GLboolean __stdcall GLee_Lazy_glIsProgramARB(GLuint program)  {if (GLeeInit()) return glIsProgramARB(program); return (GLboolean)0;}
  GLEEPFNGLISPROGRAMARBPROC GLeeFuncPtr_glIsProgramARB=GLee_Lazy_glIsProgramARB;
#endif
#endif

/* GL_ARB_fragment_program */

#ifdef __GLEE_GL_ARB_fragment_program
#endif

/* GL_ARB_vertex_buffer_object */

#ifdef __GLEE_GL_ARB_vertex_buffer_object
#ifndef GLEE_C_DEFINED_glBindBufferARB
#define GLEE_C_DEFINED_glBindBufferARB
  void __stdcall GLee_Lazy_glBindBufferARB(GLenum target, GLuint buffer)  {if (GLeeInit()) glBindBufferARB(target, buffer);}
  GLEEPFNGLBINDBUFFERARBPROC GLeeFuncPtr_glBindBufferARB=GLee_Lazy_glBindBufferARB;
#endif
#ifndef GLEE_C_DEFINED_glDeleteBuffersARB
#define GLEE_C_DEFINED_glDeleteBuffersARB
  void __stdcall GLee_Lazy_glDeleteBuffersARB(GLsizei n, const GLuint * buffers)  {if (GLeeInit()) glDeleteBuffersARB(n, buffers);}
  GLEEPFNGLDELETEBUFFERSARBPROC GLeeFuncPtr_glDeleteBuffersARB=GLee_Lazy_glDeleteBuffersARB;
#endif
#ifndef GLEE_C_DEFINED_glGenBuffersARB
#define GLEE_C_DEFINED_glGenBuffersARB
  void __stdcall GLee_Lazy_glGenBuffersARB(GLsizei n, GLuint * buffers)  {if (GLeeInit()) glGenBuffersARB(n, buffers);}
  GLEEPFNGLGENBUFFERSARBPROC GLeeFuncPtr_glGenBuffersARB=GLee_Lazy_glGenBuffersARB;
#endif
#ifndef GLEE_C_DEFINED_glIsBufferARB
#define GLEE_C_DEFINED_glIsBufferARB
  GLboolean __stdcall GLee_Lazy_glIsBufferARB(GLuint buffer)  {if (GLeeInit()) return glIsBufferARB(buffer); return (GLboolean)0;}
  GLEEPFNGLISBUFFERARBPROC GLeeFuncPtr_glIsBufferARB=GLee_Lazy_glIsBufferARB;
#endif
#ifndef GLEE_C_DEFINED_glBufferDataARB
#define GLEE_C_DEFINED_glBufferDataARB
  void __stdcall GLee_Lazy_glBufferDataARB(GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage)  {if (GLeeInit()) glBufferDataARB(target, size, data, usage);}
  GLEEPFNGLBUFFERDATAARBPROC GLeeFuncPtr_glBufferDataARB=GLee_Lazy_glBufferDataARB;
#endif
#ifndef GLEE_C_DEFINED_glBufferSubDataARB
#define GLEE_C_DEFINED_glBufferSubDataARB
  void __stdcall GLee_Lazy_glBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data)  {if (GLeeInit()) glBufferSubDataARB(target, offset, size, data);}
  GLEEPFNGLBUFFERSUBDATAARBPROC GLeeFuncPtr_glBufferSubDataARB=GLee_Lazy_glBufferSubDataARB;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferSubDataARB
#define GLEE_C_DEFINED_glGetBufferSubDataARB
  void __stdcall GLee_Lazy_glGetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid * data)  {if (GLeeInit()) glGetBufferSubDataARB(target, offset, size, data);}
  GLEEPFNGLGETBUFFERSUBDATAARBPROC GLeeFuncPtr_glGetBufferSubDataARB=GLee_Lazy_glGetBufferSubDataARB;
#endif
#ifndef GLEE_C_DEFINED_glMapBufferARB
#define GLEE_C_DEFINED_glMapBufferARB
  GLvoid* __stdcall GLee_Lazy_glMapBufferARB(GLenum target, GLenum access)  {if (GLeeInit()) return glMapBufferARB(target, access); return (GLvoid*)0;}
  GLEEPFNGLMAPBUFFERARBPROC GLeeFuncPtr_glMapBufferARB=GLee_Lazy_glMapBufferARB;
#endif
#ifndef GLEE_C_DEFINED_glUnmapBufferARB
#define GLEE_C_DEFINED_glUnmapBufferARB
  GLboolean __stdcall GLee_Lazy_glUnmapBufferARB(GLenum target)  {if (GLeeInit()) return glUnmapBufferARB(target); return (GLboolean)0;}
  GLEEPFNGLUNMAPBUFFERARBPROC GLeeFuncPtr_glUnmapBufferARB=GLee_Lazy_glUnmapBufferARB;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferParameterivARB
#define GLEE_C_DEFINED_glGetBufferParameterivARB
  void __stdcall GLee_Lazy_glGetBufferParameterivARB(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetBufferParameterivARB(target, pname, params);}
  GLEEPFNGLGETBUFFERPARAMETERIVARBPROC GLeeFuncPtr_glGetBufferParameterivARB=GLee_Lazy_glGetBufferParameterivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferPointervARB
#define GLEE_C_DEFINED_glGetBufferPointervARB
  void __stdcall GLee_Lazy_glGetBufferPointervARB(GLenum target, GLenum pname, GLvoid* * params)  {if (GLeeInit()) glGetBufferPointervARB(target, pname, params);}
  GLEEPFNGLGETBUFFERPOINTERVARBPROC GLeeFuncPtr_glGetBufferPointervARB=GLee_Lazy_glGetBufferPointervARB;
#endif
#endif

/* GL_ARB_occlusion_query */

#ifdef __GLEE_GL_ARB_occlusion_query
#ifndef GLEE_C_DEFINED_glGenQueriesARB
#define GLEE_C_DEFINED_glGenQueriesARB
  void __stdcall GLee_Lazy_glGenQueriesARB(GLsizei n, GLuint * ids)  {if (GLeeInit()) glGenQueriesARB(n, ids);}
  GLEEPFNGLGENQUERIESARBPROC GLeeFuncPtr_glGenQueriesARB=GLee_Lazy_glGenQueriesARB;
#endif
#ifndef GLEE_C_DEFINED_glDeleteQueriesARB
#define GLEE_C_DEFINED_glDeleteQueriesARB
  void __stdcall GLee_Lazy_glDeleteQueriesARB(GLsizei n, const GLuint * ids)  {if (GLeeInit()) glDeleteQueriesARB(n, ids);}
  GLEEPFNGLDELETEQUERIESARBPROC GLeeFuncPtr_glDeleteQueriesARB=GLee_Lazy_glDeleteQueriesARB;
#endif
#ifndef GLEE_C_DEFINED_glIsQueryARB
#define GLEE_C_DEFINED_glIsQueryARB
  GLboolean __stdcall GLee_Lazy_glIsQueryARB(GLuint id)  {if (GLeeInit()) return glIsQueryARB(id); return (GLboolean)0;}
  GLEEPFNGLISQUERYARBPROC GLeeFuncPtr_glIsQueryARB=GLee_Lazy_glIsQueryARB;
#endif
#ifndef GLEE_C_DEFINED_glBeginQueryARB
#define GLEE_C_DEFINED_glBeginQueryARB
  void __stdcall GLee_Lazy_glBeginQueryARB(GLenum target, GLuint id)  {if (GLeeInit()) glBeginQueryARB(target, id);}
  GLEEPFNGLBEGINQUERYARBPROC GLeeFuncPtr_glBeginQueryARB=GLee_Lazy_glBeginQueryARB;
#endif
#ifndef GLEE_C_DEFINED_glEndQueryARB
#define GLEE_C_DEFINED_glEndQueryARB
  void __stdcall GLee_Lazy_glEndQueryARB(GLenum target)  {if (GLeeInit()) glEndQueryARB(target);}
  GLEEPFNGLENDQUERYARBPROC GLeeFuncPtr_glEndQueryARB=GLee_Lazy_glEndQueryARB;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryivARB
#define GLEE_C_DEFINED_glGetQueryivARB
  void __stdcall GLee_Lazy_glGetQueryivARB(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetQueryivARB(target, pname, params);}
  GLEEPFNGLGETQUERYIVARBPROC GLeeFuncPtr_glGetQueryivARB=GLee_Lazy_glGetQueryivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryObjectivARB
#define GLEE_C_DEFINED_glGetQueryObjectivARB
  void __stdcall GLee_Lazy_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params)  {if (GLeeInit()) glGetQueryObjectivARB(id, pname, params);}
  GLEEPFNGLGETQUERYOBJECTIVARBPROC GLeeFuncPtr_glGetQueryObjectivARB=GLee_Lazy_glGetQueryObjectivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryObjectuivARB
#define GLEE_C_DEFINED_glGetQueryObjectuivARB
  void __stdcall GLee_Lazy_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params)  {if (GLeeInit()) glGetQueryObjectuivARB(id, pname, params);}
  GLEEPFNGLGETQUERYOBJECTUIVARBPROC GLeeFuncPtr_glGetQueryObjectuivARB=GLee_Lazy_glGetQueryObjectuivARB;
#endif
#endif

/* GL_ARB_shader_objects */

#ifdef __GLEE_GL_ARB_shader_objects
#ifndef GLEE_C_DEFINED_glDeleteObjectARB
#define GLEE_C_DEFINED_glDeleteObjectARB
  void __stdcall GLee_Lazy_glDeleteObjectARB(GLhandleARB obj)  {if (GLeeInit()) glDeleteObjectARB(obj);}
  GLEEPFNGLDELETEOBJECTARBPROC GLeeFuncPtr_glDeleteObjectARB=GLee_Lazy_glDeleteObjectARB;
#endif
#ifndef GLEE_C_DEFINED_glGetHandleARB
#define GLEE_C_DEFINED_glGetHandleARB
  GLhandleARB __stdcall GLee_Lazy_glGetHandleARB(GLenum pname)  {if (GLeeInit()) return glGetHandleARB(pname); return (GLhandleARB)0;}
  GLEEPFNGLGETHANDLEARBPROC GLeeFuncPtr_glGetHandleARB=GLee_Lazy_glGetHandleARB;
#endif
#ifndef GLEE_C_DEFINED_glDetachObjectARB
#define GLEE_C_DEFINED_glDetachObjectARB
  void __stdcall GLee_Lazy_glDetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj)  {if (GLeeInit()) glDetachObjectARB(containerObj, attachedObj);}
  GLEEPFNGLDETACHOBJECTARBPROC GLeeFuncPtr_glDetachObjectARB=GLee_Lazy_glDetachObjectARB;
#endif
#ifndef GLEE_C_DEFINED_glCreateShaderObjectARB
#define GLEE_C_DEFINED_glCreateShaderObjectARB
  GLhandleARB __stdcall GLee_Lazy_glCreateShaderObjectARB(GLenum shaderType)  {if (GLeeInit()) return glCreateShaderObjectARB(shaderType); return (GLhandleARB)0;}
  GLEEPFNGLCREATESHADEROBJECTARBPROC GLeeFuncPtr_glCreateShaderObjectARB=GLee_Lazy_glCreateShaderObjectARB;
#endif
#ifndef GLEE_C_DEFINED_glShaderSourceARB
#define GLEE_C_DEFINED_glShaderSourceARB
  void __stdcall GLee_Lazy_glShaderSourceARB(GLhandleARB shaderObj, GLsizei count, const GLcharARB* * string, const GLint * length)  {if (GLeeInit()) glShaderSourceARB(shaderObj, count, string, length);}
  GLEEPFNGLSHADERSOURCEARBPROC GLeeFuncPtr_glShaderSourceARB=GLee_Lazy_glShaderSourceARB;
#endif
#ifndef GLEE_C_DEFINED_glCompileShaderARB
#define GLEE_C_DEFINED_glCompileShaderARB
  void __stdcall GLee_Lazy_glCompileShaderARB(GLhandleARB shaderObj)  {if (GLeeInit()) glCompileShaderARB(shaderObj);}
  GLEEPFNGLCOMPILESHADERARBPROC GLeeFuncPtr_glCompileShaderARB=GLee_Lazy_glCompileShaderARB;
#endif
#ifndef GLEE_C_DEFINED_glCreateProgramObjectARB
#define GLEE_C_DEFINED_glCreateProgramObjectARB
  GLhandleARB __stdcall GLee_Lazy_glCreateProgramObjectARB(void)  {if (GLeeInit()) return glCreateProgramObjectARB(); return (GLhandleARB)0;}
  GLEEPFNGLCREATEPROGRAMOBJECTARBPROC GLeeFuncPtr_glCreateProgramObjectARB=GLee_Lazy_glCreateProgramObjectARB;
#endif
#ifndef GLEE_C_DEFINED_glAttachObjectARB
#define GLEE_C_DEFINED_glAttachObjectARB
  void __stdcall GLee_Lazy_glAttachObjectARB(GLhandleARB containerObj, GLhandleARB obj)  {if (GLeeInit()) glAttachObjectARB(containerObj, obj);}
  GLEEPFNGLATTACHOBJECTARBPROC GLeeFuncPtr_glAttachObjectARB=GLee_Lazy_glAttachObjectARB;
#endif
#ifndef GLEE_C_DEFINED_glLinkProgramARB
#define GLEE_C_DEFINED_glLinkProgramARB
  void __stdcall GLee_Lazy_glLinkProgramARB(GLhandleARB programObj)  {if (GLeeInit()) glLinkProgramARB(programObj);}
  GLEEPFNGLLINKPROGRAMARBPROC GLeeFuncPtr_glLinkProgramARB=GLee_Lazy_glLinkProgramARB;
#endif
#ifndef GLEE_C_DEFINED_glUseProgramObjectARB
#define GLEE_C_DEFINED_glUseProgramObjectARB
  void __stdcall GLee_Lazy_glUseProgramObjectARB(GLhandleARB programObj)  {if (GLeeInit()) glUseProgramObjectARB(programObj);}
  GLEEPFNGLUSEPROGRAMOBJECTARBPROC GLeeFuncPtr_glUseProgramObjectARB=GLee_Lazy_glUseProgramObjectARB;
#endif
#ifndef GLEE_C_DEFINED_glValidateProgramARB
#define GLEE_C_DEFINED_glValidateProgramARB
  void __stdcall GLee_Lazy_glValidateProgramARB(GLhandleARB programObj)  {if (GLeeInit()) glValidateProgramARB(programObj);}
  GLEEPFNGLVALIDATEPROGRAMARBPROC GLeeFuncPtr_glValidateProgramARB=GLee_Lazy_glValidateProgramARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform1fARB
#define GLEE_C_DEFINED_glUniform1fARB
  void __stdcall GLee_Lazy_glUniform1fARB(GLint location, GLfloat v0)  {if (GLeeInit()) glUniform1fARB(location, v0);}
  GLEEPFNGLUNIFORM1FARBPROC GLeeFuncPtr_glUniform1fARB=GLee_Lazy_glUniform1fARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform2fARB
#define GLEE_C_DEFINED_glUniform2fARB
  void __stdcall GLee_Lazy_glUniform2fARB(GLint location, GLfloat v0, GLfloat v1)  {if (GLeeInit()) glUniform2fARB(location, v0, v1);}
  GLEEPFNGLUNIFORM2FARBPROC GLeeFuncPtr_glUniform2fARB=GLee_Lazy_glUniform2fARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform3fARB
#define GLEE_C_DEFINED_glUniform3fARB
  void __stdcall GLee_Lazy_glUniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)  {if (GLeeInit()) glUniform3fARB(location, v0, v1, v2);}
  GLEEPFNGLUNIFORM3FARBPROC GLeeFuncPtr_glUniform3fARB=GLee_Lazy_glUniform3fARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform4fARB
#define GLEE_C_DEFINED_glUniform4fARB
  void __stdcall GLee_Lazy_glUniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)  {if (GLeeInit()) glUniform4fARB(location, v0, v1, v2, v3);}
  GLEEPFNGLUNIFORM4FARBPROC GLeeFuncPtr_glUniform4fARB=GLee_Lazy_glUniform4fARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform1iARB
#define GLEE_C_DEFINED_glUniform1iARB
  void __stdcall GLee_Lazy_glUniform1iARB(GLint location, GLint v0)  {if (GLeeInit()) glUniform1iARB(location, v0);}
  GLEEPFNGLUNIFORM1IARBPROC GLeeFuncPtr_glUniform1iARB=GLee_Lazy_glUniform1iARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform2iARB
#define GLEE_C_DEFINED_glUniform2iARB
  void __stdcall GLee_Lazy_glUniform2iARB(GLint location, GLint v0, GLint v1)  {if (GLeeInit()) glUniform2iARB(location, v0, v1);}
  GLEEPFNGLUNIFORM2IARBPROC GLeeFuncPtr_glUniform2iARB=GLee_Lazy_glUniform2iARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform3iARB
#define GLEE_C_DEFINED_glUniform3iARB
  void __stdcall GLee_Lazy_glUniform3iARB(GLint location, GLint v0, GLint v1, GLint v2)  {if (GLeeInit()) glUniform3iARB(location, v0, v1, v2);}
  GLEEPFNGLUNIFORM3IARBPROC GLeeFuncPtr_glUniform3iARB=GLee_Lazy_glUniform3iARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform4iARB
#define GLEE_C_DEFINED_glUniform4iARB
  void __stdcall GLee_Lazy_glUniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)  {if (GLeeInit()) glUniform4iARB(location, v0, v1, v2, v3);}
  GLEEPFNGLUNIFORM4IARBPROC GLeeFuncPtr_glUniform4iARB=GLee_Lazy_glUniform4iARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform1fvARB
#define GLEE_C_DEFINED_glUniform1fvARB
  void __stdcall GLee_Lazy_glUniform1fvARB(GLint location, GLsizei count, const GLfloat * value)  {if (GLeeInit()) glUniform1fvARB(location, count, value);}
  GLEEPFNGLUNIFORM1FVARBPROC GLeeFuncPtr_glUniform1fvARB=GLee_Lazy_glUniform1fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform2fvARB
#define GLEE_C_DEFINED_glUniform2fvARB
  void __stdcall GLee_Lazy_glUniform2fvARB(GLint location, GLsizei count, const GLfloat * value)  {if (GLeeInit()) glUniform2fvARB(location, count, value);}
  GLEEPFNGLUNIFORM2FVARBPROC GLeeFuncPtr_glUniform2fvARB=GLee_Lazy_glUniform2fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform3fvARB
#define GLEE_C_DEFINED_glUniform3fvARB
  void __stdcall GLee_Lazy_glUniform3fvARB(GLint location, GLsizei count, const GLfloat * value)  {if (GLeeInit()) glUniform3fvARB(location, count, value);}
  GLEEPFNGLUNIFORM3FVARBPROC GLeeFuncPtr_glUniform3fvARB=GLee_Lazy_glUniform3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform4fvARB
#define GLEE_C_DEFINED_glUniform4fvARB
  void __stdcall GLee_Lazy_glUniform4fvARB(GLint location, GLsizei count, const GLfloat * value)  {if (GLeeInit()) glUniform4fvARB(location, count, value);}
  GLEEPFNGLUNIFORM4FVARBPROC GLeeFuncPtr_glUniform4fvARB=GLee_Lazy_glUniform4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform1ivARB
#define GLEE_C_DEFINED_glUniform1ivARB
  void __stdcall GLee_Lazy_glUniform1ivARB(GLint location, GLsizei count, const GLint * value)  {if (GLeeInit()) glUniform1ivARB(location, count, value);}
  GLEEPFNGLUNIFORM1IVARBPROC GLeeFuncPtr_glUniform1ivARB=GLee_Lazy_glUniform1ivARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform2ivARB
#define GLEE_C_DEFINED_glUniform2ivARB
  void __stdcall GLee_Lazy_glUniform2ivARB(GLint location, GLsizei count, const GLint * value)  {if (GLeeInit()) glUniform2ivARB(location, count, value);}
  GLEEPFNGLUNIFORM2IVARBPROC GLeeFuncPtr_glUniform2ivARB=GLee_Lazy_glUniform2ivARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform3ivARB
#define GLEE_C_DEFINED_glUniform3ivARB
  void __stdcall GLee_Lazy_glUniform3ivARB(GLint location, GLsizei count, const GLint * value)  {if (GLeeInit()) glUniform3ivARB(location, count, value);}
  GLEEPFNGLUNIFORM3IVARBPROC GLeeFuncPtr_glUniform3ivARB=GLee_Lazy_glUniform3ivARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform4ivARB
#define GLEE_C_DEFINED_glUniform4ivARB
  void __stdcall GLee_Lazy_glUniform4ivARB(GLint location, GLsizei count, const GLint * value)  {if (GLeeInit()) glUniform4ivARB(location, count, value);}
  GLEEPFNGLUNIFORM4IVARBPROC GLeeFuncPtr_glUniform4ivARB=GLee_Lazy_glUniform4ivARB;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix2fvARB
#define GLEE_C_DEFINED_glUniformMatrix2fvARB
  void __stdcall GLee_Lazy_glUniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glUniformMatrix2fvARB(location, count, transpose, value);}
  GLEEPFNGLUNIFORMMATRIX2FVARBPROC GLeeFuncPtr_glUniformMatrix2fvARB=GLee_Lazy_glUniformMatrix2fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix3fvARB
#define GLEE_C_DEFINED_glUniformMatrix3fvARB
  void __stdcall GLee_Lazy_glUniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glUniformMatrix3fvARB(location, count, transpose, value);}
  GLEEPFNGLUNIFORMMATRIX3FVARBPROC GLeeFuncPtr_glUniformMatrix3fvARB=GLee_Lazy_glUniformMatrix3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix4fvARB
#define GLEE_C_DEFINED_glUniformMatrix4fvARB
  void __stdcall GLee_Lazy_glUniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glUniformMatrix4fvARB(location, count, transpose, value);}
  GLEEPFNGLUNIFORMMATRIX4FVARBPROC GLeeFuncPtr_glUniformMatrix4fvARB=GLee_Lazy_glUniformMatrix4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetObjectParameterfvARB
#define GLEE_C_DEFINED_glGetObjectParameterfvARB
  void __stdcall GLee_Lazy_glGetObjectParameterfvARB(GLhandleARB obj, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetObjectParameterfvARB(obj, pname, params);}
  GLEEPFNGLGETOBJECTPARAMETERFVARBPROC GLeeFuncPtr_glGetObjectParameterfvARB=GLee_Lazy_glGetObjectParameterfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetObjectParameterivARB
#define GLEE_C_DEFINED_glGetObjectParameterivARB
  void __stdcall GLee_Lazy_glGetObjectParameterivARB(GLhandleARB obj, GLenum pname, GLint * params)  {if (GLeeInit()) glGetObjectParameterivARB(obj, pname, params);}
  GLEEPFNGLGETOBJECTPARAMETERIVARBPROC GLeeFuncPtr_glGetObjectParameterivARB=GLee_Lazy_glGetObjectParameterivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetInfoLogARB
#define GLEE_C_DEFINED_glGetInfoLogARB
  void __stdcall GLee_Lazy_glGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog)  {if (GLeeInit()) glGetInfoLogARB(obj, maxLength, length, infoLog);}
  GLEEPFNGLGETINFOLOGARBPROC GLeeFuncPtr_glGetInfoLogARB=GLee_Lazy_glGetInfoLogARB;
#endif
#ifndef GLEE_C_DEFINED_glGetAttachedObjectsARB
#define GLEE_C_DEFINED_glGetAttachedObjectsARB
  void __stdcall GLee_Lazy_glGetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei * count, GLhandleARB * obj)  {if (GLeeInit()) glGetAttachedObjectsARB(containerObj, maxCount, count, obj);}
  GLEEPFNGLGETATTACHEDOBJECTSARBPROC GLeeFuncPtr_glGetAttachedObjectsARB=GLee_Lazy_glGetAttachedObjectsARB;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformLocationARB
#define GLEE_C_DEFINED_glGetUniformLocationARB
  GLint __stdcall GLee_Lazy_glGetUniformLocationARB(GLhandleARB programObj, const GLcharARB * name)  {if (GLeeInit()) return glGetUniformLocationARB(programObj, name); return (GLint)0;}
  GLEEPFNGLGETUNIFORMLOCATIONARBPROC GLeeFuncPtr_glGetUniformLocationARB=GLee_Lazy_glGetUniformLocationARB;
#endif
#ifndef GLEE_C_DEFINED_glGetActiveUniformARB
#define GLEE_C_DEFINED_glGetActiveUniformARB
  void __stdcall GLee_Lazy_glGetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name)  {if (GLeeInit()) glGetActiveUniformARB(programObj, index, maxLength, length, size, type, name);}
  GLEEPFNGLGETACTIVEUNIFORMARBPROC GLeeFuncPtr_glGetActiveUniformARB=GLee_Lazy_glGetActiveUniformARB;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformfvARB
#define GLEE_C_DEFINED_glGetUniformfvARB
  void __stdcall GLee_Lazy_glGetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat * params)  {if (GLeeInit()) glGetUniformfvARB(programObj, location, params);}
  GLEEPFNGLGETUNIFORMFVARBPROC GLeeFuncPtr_glGetUniformfvARB=GLee_Lazy_glGetUniformfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformivARB
#define GLEE_C_DEFINED_glGetUniformivARB
  void __stdcall GLee_Lazy_glGetUniformivARB(GLhandleARB programObj, GLint location, GLint * params)  {if (GLeeInit()) glGetUniformivARB(programObj, location, params);}
  GLEEPFNGLGETUNIFORMIVARBPROC GLeeFuncPtr_glGetUniformivARB=GLee_Lazy_glGetUniformivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetShaderSourceARB
#define GLEE_C_DEFINED_glGetShaderSourceARB
  void __stdcall GLee_Lazy_glGetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * source)  {if (GLeeInit()) glGetShaderSourceARB(obj, maxLength, length, source);}
  GLEEPFNGLGETSHADERSOURCEARBPROC GLeeFuncPtr_glGetShaderSourceARB=GLee_Lazy_glGetShaderSourceARB;
#endif
#endif

/* GL_ARB_vertex_shader */

#ifdef __GLEE_GL_ARB_vertex_shader
#ifndef GLEE_C_DEFINED_glBindAttribLocationARB
#define GLEE_C_DEFINED_glBindAttribLocationARB
  void __stdcall GLee_Lazy_glBindAttribLocationARB(GLhandleARB programObj, GLuint index, const GLcharARB * name)  {if (GLeeInit()) glBindAttribLocationARB(programObj, index, name);}
  GLEEPFNGLBINDATTRIBLOCATIONARBPROC GLeeFuncPtr_glBindAttribLocationARB=GLee_Lazy_glBindAttribLocationARB;
#endif
#ifndef GLEE_C_DEFINED_glGetActiveAttribARB
#define GLEE_C_DEFINED_glGetActiveAttribARB
  void __stdcall GLee_Lazy_glGetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name)  {if (GLeeInit()) glGetActiveAttribARB(programObj, index, maxLength, length, size, type, name);}
  GLEEPFNGLGETACTIVEATTRIBARBPROC GLeeFuncPtr_glGetActiveAttribARB=GLee_Lazy_glGetActiveAttribARB;
#endif
#ifndef GLEE_C_DEFINED_glGetAttribLocationARB
#define GLEE_C_DEFINED_glGetAttribLocationARB
  GLint __stdcall GLee_Lazy_glGetAttribLocationARB(GLhandleARB programObj, const GLcharARB * name)  {if (GLeeInit()) return glGetAttribLocationARB(programObj, name); return (GLint)0;}
  GLEEPFNGLGETATTRIBLOCATIONARBPROC GLeeFuncPtr_glGetAttribLocationARB=GLee_Lazy_glGetAttribLocationARB;
#endif
#endif

/* GL_ARB_fragment_shader */

#ifdef __GLEE_GL_ARB_fragment_shader
#endif

/* GL_ARB_shading_language_100 */

#ifdef __GLEE_GL_ARB_shading_language_100
#endif

/* GL_ARB_texture_non_power_of_two */

#ifdef __GLEE_GL_ARB_texture_non_power_of_two
#endif

/* GL_ARB_point_sprite */

#ifdef __GLEE_GL_ARB_point_sprite
#endif

/* GL_ARB_fragment_program_shadow */

#ifdef __GLEE_GL_ARB_fragment_program_shadow
#endif

/* GL_ARB_draw_buffers */

#ifdef __GLEE_GL_ARB_draw_buffers
#ifndef GLEE_C_DEFINED_glDrawBuffersARB
#define GLEE_C_DEFINED_glDrawBuffersARB
  void __stdcall GLee_Lazy_glDrawBuffersARB(GLsizei n, const GLenum * bufs)  {if (GLeeInit()) glDrawBuffersARB(n, bufs);}
  GLEEPFNGLDRAWBUFFERSARBPROC GLeeFuncPtr_glDrawBuffersARB=GLee_Lazy_glDrawBuffersARB;
#endif
#endif

/* GL_ARB_texture_rectangle */

#ifdef __GLEE_GL_ARB_texture_rectangle
#endif

/* GL_ARB_color_buffer_float */

#ifdef __GLEE_GL_ARB_color_buffer_float
#ifndef GLEE_C_DEFINED_glClampColorARB
#define GLEE_C_DEFINED_glClampColorARB
  void __stdcall GLee_Lazy_glClampColorARB(GLenum target, GLenum clamp)  {if (GLeeInit()) glClampColorARB(target, clamp);}
  GLEEPFNGLCLAMPCOLORARBPROC GLeeFuncPtr_glClampColorARB=GLee_Lazy_glClampColorARB;
#endif
#endif

/* GL_ARB_half_float_pixel */

#ifdef __GLEE_GL_ARB_half_float_pixel
#endif

/* GL_ARB_texture_float */

#ifdef __GLEE_GL_ARB_texture_float
#endif

/* GL_ARB_pixel_buffer_object */

#ifdef __GLEE_GL_ARB_pixel_buffer_object
#endif

/* GL_ARB_depth_buffer_float */

#ifdef __GLEE_GL_ARB_depth_buffer_float
#endif

/* GL_ARB_draw_instanced */

#ifdef __GLEE_GL_ARB_draw_instanced
#ifndef GLEE_C_DEFINED_glDrawArraysInstancedARB
#define GLEE_C_DEFINED_glDrawArraysInstancedARB
  void __stdcall GLee_Lazy_glDrawArraysInstancedARB(GLenum mode, GLint first, GLsizei count, GLsizei primcount)  {if (GLeeInit()) glDrawArraysInstancedARB(mode, first, count, primcount);}
  GLEEPFNGLDRAWARRAYSINSTANCEDARBPROC GLeeFuncPtr_glDrawArraysInstancedARB=GLee_Lazy_glDrawArraysInstancedARB;
#endif
#ifndef GLEE_C_DEFINED_glDrawElementsInstancedARB
#define GLEE_C_DEFINED_glDrawElementsInstancedARB
  void __stdcall GLee_Lazy_glDrawElementsInstancedARB(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount)  {if (GLeeInit()) glDrawElementsInstancedARB(mode, count, type, indices, primcount);}
  GLEEPFNGLDRAWELEMENTSINSTANCEDARBPROC GLeeFuncPtr_glDrawElementsInstancedARB=GLee_Lazy_glDrawElementsInstancedARB;
#endif
#endif

/* GL_ARB_framebuffer_object */

#ifdef __GLEE_GL_ARB_framebuffer_object
#ifndef GLEE_C_DEFINED_glIsRenderbuffer
#define GLEE_C_DEFINED_glIsRenderbuffer
  GLboolean __stdcall GLee_Lazy_glIsRenderbuffer(GLuint renderbuffer)  {if (GLeeInit()) return glIsRenderbuffer(renderbuffer); return (GLboolean)0;}
  GLEEPFNGLISRENDERBUFFERPROC GLeeFuncPtr_glIsRenderbuffer=GLee_Lazy_glIsRenderbuffer;
#endif
#ifndef GLEE_C_DEFINED_glBindRenderbuffer
#define GLEE_C_DEFINED_glBindRenderbuffer
  void __stdcall GLee_Lazy_glBindRenderbuffer(GLenum target, GLuint renderbuffer)  {if (GLeeInit()) glBindRenderbuffer(target, renderbuffer);}
  GLEEPFNGLBINDRENDERBUFFERPROC GLeeFuncPtr_glBindRenderbuffer=GLee_Lazy_glBindRenderbuffer;
#endif
#ifndef GLEE_C_DEFINED_glDeleteRenderbuffers
#define GLEE_C_DEFINED_glDeleteRenderbuffers
  void __stdcall GLee_Lazy_glDeleteRenderbuffers(GLsizei n, const GLuint * renderbuffers)  {if (GLeeInit()) glDeleteRenderbuffers(n, renderbuffers);}
  GLEEPFNGLDELETERENDERBUFFERSPROC GLeeFuncPtr_glDeleteRenderbuffers=GLee_Lazy_glDeleteRenderbuffers;
#endif
#ifndef GLEE_C_DEFINED_glGenRenderbuffers
#define GLEE_C_DEFINED_glGenRenderbuffers
  void __stdcall GLee_Lazy_glGenRenderbuffers(GLsizei n, GLuint * renderbuffers)  {if (GLeeInit()) glGenRenderbuffers(n, renderbuffers);}
  GLEEPFNGLGENRENDERBUFFERSPROC GLeeFuncPtr_glGenRenderbuffers=GLee_Lazy_glGenRenderbuffers;
#endif
#ifndef GLEE_C_DEFINED_glRenderbufferStorage
#define GLEE_C_DEFINED_glRenderbufferStorage
  void __stdcall GLee_Lazy_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)  {if (GLeeInit()) glRenderbufferStorage(target, internalformat, width, height);}
  GLEEPFNGLRENDERBUFFERSTORAGEPROC GLeeFuncPtr_glRenderbufferStorage=GLee_Lazy_glRenderbufferStorage;
#endif
#ifndef GLEE_C_DEFINED_glGetRenderbufferParameteriv
#define GLEE_C_DEFINED_glGetRenderbufferParameteriv
  void __stdcall GLee_Lazy_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetRenderbufferParameteriv(target, pname, params);}
  GLEEPFNGLGETRENDERBUFFERPARAMETERIVPROC GLeeFuncPtr_glGetRenderbufferParameteriv=GLee_Lazy_glGetRenderbufferParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glIsFramebuffer
#define GLEE_C_DEFINED_glIsFramebuffer
  GLboolean __stdcall GLee_Lazy_glIsFramebuffer(GLuint framebuffer)  {if (GLeeInit()) return glIsFramebuffer(framebuffer); return (GLboolean)0;}
  GLEEPFNGLISFRAMEBUFFERPROC GLeeFuncPtr_glIsFramebuffer=GLee_Lazy_glIsFramebuffer;
#endif
#ifndef GLEE_C_DEFINED_glBindFramebuffer
#define GLEE_C_DEFINED_glBindFramebuffer
  void __stdcall GLee_Lazy_glBindFramebuffer(GLenum target, GLuint framebuffer)  {if (GLeeInit()) glBindFramebuffer(target, framebuffer);}
  GLEEPFNGLBINDFRAMEBUFFERPROC GLeeFuncPtr_glBindFramebuffer=GLee_Lazy_glBindFramebuffer;
#endif
#ifndef GLEE_C_DEFINED_glDeleteFramebuffers
#define GLEE_C_DEFINED_glDeleteFramebuffers
  void __stdcall GLee_Lazy_glDeleteFramebuffers(GLsizei n, const GLuint * framebuffers)  {if (GLeeInit()) glDeleteFramebuffers(n, framebuffers);}
  GLEEPFNGLDELETEFRAMEBUFFERSPROC GLeeFuncPtr_glDeleteFramebuffers=GLee_Lazy_glDeleteFramebuffers;
#endif
#ifndef GLEE_C_DEFINED_glGenFramebuffers
#define GLEE_C_DEFINED_glGenFramebuffers
  void __stdcall GLee_Lazy_glGenFramebuffers(GLsizei n, GLuint * framebuffers)  {if (GLeeInit()) glGenFramebuffers(n, framebuffers);}
  GLEEPFNGLGENFRAMEBUFFERSPROC GLeeFuncPtr_glGenFramebuffers=GLee_Lazy_glGenFramebuffers;
#endif
#ifndef GLEE_C_DEFINED_glCheckFramebufferStatus
#define GLEE_C_DEFINED_glCheckFramebufferStatus
  GLenum __stdcall GLee_Lazy_glCheckFramebufferStatus(GLenum target)  {if (GLeeInit()) return glCheckFramebufferStatus(target); return (GLenum)0;}
  GLEEPFNGLCHECKFRAMEBUFFERSTATUSPROC GLeeFuncPtr_glCheckFramebufferStatus=GLee_Lazy_glCheckFramebufferStatus;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTexture1D
#define GLEE_C_DEFINED_glFramebufferTexture1D
  void __stdcall GLee_Lazy_glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)  {if (GLeeInit()) glFramebufferTexture1D(target, attachment, textarget, texture, level);}
  GLEEPFNGLFRAMEBUFFERTEXTURE1DPROC GLeeFuncPtr_glFramebufferTexture1D=GLee_Lazy_glFramebufferTexture1D;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTexture2D
#define GLEE_C_DEFINED_glFramebufferTexture2D
  void __stdcall GLee_Lazy_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)  {if (GLeeInit()) glFramebufferTexture2D(target, attachment, textarget, texture, level);}
  GLEEPFNGLFRAMEBUFFERTEXTURE2DPROC GLeeFuncPtr_glFramebufferTexture2D=GLee_Lazy_glFramebufferTexture2D;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTexture3D
#define GLEE_C_DEFINED_glFramebufferTexture3D
  void __stdcall GLee_Lazy_glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)  {if (GLeeInit()) glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);}
  GLEEPFNGLFRAMEBUFFERTEXTURE3DPROC GLeeFuncPtr_glFramebufferTexture3D=GLee_Lazy_glFramebufferTexture3D;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferRenderbuffer
#define GLEE_C_DEFINED_glFramebufferRenderbuffer
  void __stdcall GLee_Lazy_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)  {if (GLeeInit()) glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);}
  GLEEPFNGLFRAMEBUFFERRENDERBUFFERPROC GLeeFuncPtr_glFramebufferRenderbuffer=GLee_Lazy_glFramebufferRenderbuffer;
#endif
#ifndef GLEE_C_DEFINED_glGetFramebufferAttachmentParameteriv
#define GLEE_C_DEFINED_glGetFramebufferAttachmentParameteriv
  void __stdcall GLee_Lazy_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint * params)  {if (GLeeInit()) glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);}
  GLEEPFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC GLeeFuncPtr_glGetFramebufferAttachmentParameteriv=GLee_Lazy_glGetFramebufferAttachmentParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glGenerateMipmap
#define GLEE_C_DEFINED_glGenerateMipmap
  void __stdcall GLee_Lazy_glGenerateMipmap(GLenum target)  {if (GLeeInit()) glGenerateMipmap(target);}
  GLEEPFNGLGENERATEMIPMAPPROC GLeeFuncPtr_glGenerateMipmap=GLee_Lazy_glGenerateMipmap;
#endif
#ifndef GLEE_C_DEFINED_glBlitFramebuffer
#define GLEE_C_DEFINED_glBlitFramebuffer
  void __stdcall GLee_Lazy_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)  {if (GLeeInit()) glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);}
  GLEEPFNGLBLITFRAMEBUFFERPROC GLeeFuncPtr_glBlitFramebuffer=GLee_Lazy_glBlitFramebuffer;
#endif
#ifndef GLEE_C_DEFINED_glRenderbufferStorageMultisample
#define GLEE_C_DEFINED_glRenderbufferStorageMultisample
  void __stdcall GLee_Lazy_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)  {if (GLeeInit()) glRenderbufferStorageMultisample(target, samples, internalformat, width, height);}
  GLEEPFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC GLeeFuncPtr_glRenderbufferStorageMultisample=GLee_Lazy_glRenderbufferStorageMultisample;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureLayer
#define GLEE_C_DEFINED_glFramebufferTextureLayer
  void __stdcall GLee_Lazy_glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)  {if (GLeeInit()) glFramebufferTextureLayer(target, attachment, texture, level, layer);}
  GLEEPFNGLFRAMEBUFFERTEXTURELAYERPROC GLeeFuncPtr_glFramebufferTextureLayer=GLee_Lazy_glFramebufferTextureLayer;
#endif
#endif

/* GL_ARB_framebuffer_sRGB */

#ifdef __GLEE_GL_ARB_framebuffer_sRGB
#endif

/* GL_ARB_geometry_shader4 */

#ifdef __GLEE_GL_ARB_geometry_shader4
#ifndef GLEE_C_DEFINED_glProgramParameteriARB
#define GLEE_C_DEFINED_glProgramParameteriARB
  void __stdcall GLee_Lazy_glProgramParameteriARB(GLuint program, GLenum pname, GLint value)  {if (GLeeInit()) glProgramParameteriARB(program, pname, value);}
  GLEEPFNGLPROGRAMPARAMETERIARBPROC GLeeFuncPtr_glProgramParameteriARB=GLee_Lazy_glProgramParameteriARB;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureARB
#define GLEE_C_DEFINED_glFramebufferTextureARB
  void __stdcall GLee_Lazy_glFramebufferTextureARB(GLenum target, GLenum attachment, GLuint texture, GLint level)  {if (GLeeInit()) glFramebufferTextureARB(target, attachment, texture, level);}
  GLEEPFNGLFRAMEBUFFERTEXTUREARBPROC GLeeFuncPtr_glFramebufferTextureARB=GLee_Lazy_glFramebufferTextureARB;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureLayerARB
#define GLEE_C_DEFINED_glFramebufferTextureLayerARB
  void __stdcall GLee_Lazy_glFramebufferTextureLayerARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)  {if (GLeeInit()) glFramebufferTextureLayerARB(target, attachment, texture, level, layer);}
  GLEEPFNGLFRAMEBUFFERTEXTURELAYERARBPROC GLeeFuncPtr_glFramebufferTextureLayerARB=GLee_Lazy_glFramebufferTextureLayerARB;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureFaceARB
#define GLEE_C_DEFINED_glFramebufferTextureFaceARB
  void __stdcall GLee_Lazy_glFramebufferTextureFaceARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face)  {if (GLeeInit()) glFramebufferTextureFaceARB(target, attachment, texture, level, face);}
  GLEEPFNGLFRAMEBUFFERTEXTUREFACEARBPROC GLeeFuncPtr_glFramebufferTextureFaceARB=GLee_Lazy_glFramebufferTextureFaceARB;
#endif
#endif

/* GL_ARB_half_float_vertex */

#ifdef __GLEE_GL_ARB_half_float_vertex
#endif

/* GL_ARB_instanced_arrays */

#ifdef __GLEE_GL_ARB_instanced_arrays
#ifndef GLEE_C_DEFINED_glVertexAttribDivisor
#define GLEE_C_DEFINED_glVertexAttribDivisor
  void __stdcall GLee_Lazy_glVertexAttribDivisor(GLuint index, GLuint divisor)  {if (GLeeInit()) glVertexAttribDivisor(index, divisor);}
  GLEEPFNGLVERTEXATTRIBDIVISORPROC GLeeFuncPtr_glVertexAttribDivisor=GLee_Lazy_glVertexAttribDivisor;
#endif
#endif

/* GL_ARB_map_buffer_range */

#ifdef __GLEE_GL_ARB_map_buffer_range
#ifndef GLEE_C_DEFINED_glMapBufferRange
#define GLEE_C_DEFINED_glMapBufferRange
  void __stdcall GLee_Lazy_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)  {if (GLeeInit()) glMapBufferRange(target, offset, length, access);}
  GLEEPFNGLMAPBUFFERRANGEPROC GLeeFuncPtr_glMapBufferRange=GLee_Lazy_glMapBufferRange;
#endif
#ifndef GLEE_C_DEFINED_glFlushMappedBufferRange
#define GLEE_C_DEFINED_glFlushMappedBufferRange
  void __stdcall GLee_Lazy_glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)  {if (GLeeInit()) glFlushMappedBufferRange(target, offset, length);}
  GLEEPFNGLFLUSHMAPPEDBUFFERRANGEPROC GLeeFuncPtr_glFlushMappedBufferRange=GLee_Lazy_glFlushMappedBufferRange;
#endif
#endif

/* GL_ARB_texture_buffer_object */

#ifdef __GLEE_GL_ARB_texture_buffer_object
#ifndef GLEE_C_DEFINED_glTexBufferARB
#define GLEE_C_DEFINED_glTexBufferARB
  void __stdcall GLee_Lazy_glTexBufferARB(GLenum target, GLenum internalformat, GLuint buffer)  {if (GLeeInit()) glTexBufferARB(target, internalformat, buffer);}
  GLEEPFNGLTEXBUFFERARBPROC GLeeFuncPtr_glTexBufferARB=GLee_Lazy_glTexBufferARB;
#endif
#endif

/* GL_ARB_texture_compression_rgtc */

#ifdef __GLEE_GL_ARB_texture_compression_rgtc
#endif

/* GL_ARB_texture_rg */

#ifdef __GLEE_GL_ARB_texture_rg
#endif

/* GL_ARB_vertex_array_object */

#ifdef __GLEE_GL_ARB_vertex_array_object
#ifndef GLEE_C_DEFINED_glBindVertexArray
#define GLEE_C_DEFINED_glBindVertexArray
  void __stdcall GLee_Lazy_glBindVertexArray(GLuint array)  {if (GLeeInit()) glBindVertexArray(array);}
  GLEEPFNGLBINDVERTEXARRAYPROC GLeeFuncPtr_glBindVertexArray=GLee_Lazy_glBindVertexArray;
#endif
#ifndef GLEE_C_DEFINED_glDeleteVertexArrays
#define GLEE_C_DEFINED_glDeleteVertexArrays
  void __stdcall GLee_Lazy_glDeleteVertexArrays(GLsizei n, const GLuint * arrays)  {if (GLeeInit()) glDeleteVertexArrays(n, arrays);}
  GLEEPFNGLDELETEVERTEXARRAYSPROC GLeeFuncPtr_glDeleteVertexArrays=GLee_Lazy_glDeleteVertexArrays;
#endif
#ifndef GLEE_C_DEFINED_glGenVertexArrays
#define GLEE_C_DEFINED_glGenVertexArrays
  void __stdcall GLee_Lazy_glGenVertexArrays(GLsizei n, GLuint * arrays)  {if (GLeeInit()) glGenVertexArrays(n, arrays);}
  GLEEPFNGLGENVERTEXARRAYSPROC GLeeFuncPtr_glGenVertexArrays=GLee_Lazy_glGenVertexArrays;
#endif
#ifndef GLEE_C_DEFINED_glIsVertexArray
#define GLEE_C_DEFINED_glIsVertexArray
  GLboolean __stdcall GLee_Lazy_glIsVertexArray(GLuint array)  {if (GLeeInit()) return glIsVertexArray(array); return (GLboolean)0;}
  GLEEPFNGLISVERTEXARRAYPROC GLeeFuncPtr_glIsVertexArray=GLee_Lazy_glIsVertexArray;
#endif
#endif

/* GL_EXT_abgr */

#ifdef __GLEE_GL_EXT_abgr
#endif

/* GL_EXT_blend_color */

#ifdef __GLEE_GL_EXT_blend_color
#ifndef GLEE_C_DEFINED_glBlendColorEXT
#define GLEE_C_DEFINED_glBlendColorEXT
  void __stdcall GLee_Lazy_glBlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)  {if (GLeeInit()) glBlendColorEXT(red, green, blue, alpha);}
  GLEEPFNGLBLENDCOLOREXTPROC GLeeFuncPtr_glBlendColorEXT=GLee_Lazy_glBlendColorEXT;
#endif
#endif

/* GL_EXT_polygon_offset */

#ifdef __GLEE_GL_EXT_polygon_offset
#ifndef GLEE_C_DEFINED_glPolygonOffsetEXT
#define GLEE_C_DEFINED_glPolygonOffsetEXT
  void __stdcall GLee_Lazy_glPolygonOffsetEXT(GLfloat factor, GLfloat bias)  {if (GLeeInit()) glPolygonOffsetEXT(factor, bias);}
  GLEEPFNGLPOLYGONOFFSETEXTPROC GLeeFuncPtr_glPolygonOffsetEXT=GLee_Lazy_glPolygonOffsetEXT;
#endif
#endif

/* GL_EXT_texture */

#ifdef __GLEE_GL_EXT_texture
#endif

/* GL_EXT_texture3D */

#ifdef __GLEE_GL_EXT_texture3D
#ifndef GLEE_C_DEFINED_glTexImage3DEXT
#define GLEE_C_DEFINED_glTexImage3DEXT
  void __stdcall GLee_Lazy_glTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexImage3DEXT(target, level, internalformat, width, height, depth, border, format, type, pixels);}
  GLEEPFNGLTEXIMAGE3DEXTPROC GLeeFuncPtr_glTexImage3DEXT=GLee_Lazy_glTexImage3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glTexSubImage3DEXT
#define GLEE_C_DEFINED_glTexSubImage3DEXT
  void __stdcall GLee_Lazy_glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);}
  GLEEPFNGLTEXSUBIMAGE3DEXTPROC GLeeFuncPtr_glTexSubImage3DEXT=GLee_Lazy_glTexSubImage3DEXT;
#endif
#endif

/* GL_SGIS_texture_filter4 */

#ifdef __GLEE_GL_SGIS_texture_filter4
#ifndef GLEE_C_DEFINED_glGetTexFilterFuncSGIS
#define GLEE_C_DEFINED_glGetTexFilterFuncSGIS
  void __stdcall GLee_Lazy_glGetTexFilterFuncSGIS(GLenum target, GLenum filter, GLfloat * weights)  {if (GLeeInit()) glGetTexFilterFuncSGIS(target, filter, weights);}
  GLEEPFNGLGETTEXFILTERFUNCSGISPROC GLeeFuncPtr_glGetTexFilterFuncSGIS=GLee_Lazy_glGetTexFilterFuncSGIS;
#endif
#ifndef GLEE_C_DEFINED_glTexFilterFuncSGIS
#define GLEE_C_DEFINED_glTexFilterFuncSGIS
  void __stdcall GLee_Lazy_glTexFilterFuncSGIS(GLenum target, GLenum filter, GLsizei n, const GLfloat * weights)  {if (GLeeInit()) glTexFilterFuncSGIS(target, filter, n, weights);}
  GLEEPFNGLTEXFILTERFUNCSGISPROC GLeeFuncPtr_glTexFilterFuncSGIS=GLee_Lazy_glTexFilterFuncSGIS;
#endif
#endif

/* GL_EXT_subtexture */

#ifdef __GLEE_GL_EXT_subtexture
#ifndef GLEE_C_DEFINED_glTexSubImage1DEXT
#define GLEE_C_DEFINED_glTexSubImage1DEXT
  void __stdcall GLee_Lazy_glTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexSubImage1DEXT(target, level, xoffset, width, format, type, pixels);}
  GLEEPFNGLTEXSUBIMAGE1DEXTPROC GLeeFuncPtr_glTexSubImage1DEXT=GLee_Lazy_glTexSubImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glTexSubImage2DEXT
#define GLEE_C_DEFINED_glTexSubImage2DEXT
  void __stdcall GLee_Lazy_glTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexSubImage2DEXT(target, level, xoffset, yoffset, width, height, format, type, pixels);}
  GLEEPFNGLTEXSUBIMAGE2DEXTPROC GLeeFuncPtr_glTexSubImage2DEXT=GLee_Lazy_glTexSubImage2DEXT;
#endif
#endif

/* GL_EXT_copy_texture */

#ifdef __GLEE_GL_EXT_copy_texture
#ifndef GLEE_C_DEFINED_glCopyTexImage1DEXT
#define GLEE_C_DEFINED_glCopyTexImage1DEXT
  void __stdcall GLee_Lazy_glCopyTexImage1DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)  {if (GLeeInit()) glCopyTexImage1DEXT(target, level, internalformat, x, y, width, border);}
  GLEEPFNGLCOPYTEXIMAGE1DEXTPROC GLeeFuncPtr_glCopyTexImage1DEXT=GLee_Lazy_glCopyTexImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTexImage2DEXT
#define GLEE_C_DEFINED_glCopyTexImage2DEXT
  void __stdcall GLee_Lazy_glCopyTexImage2DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)  {if (GLeeInit()) glCopyTexImage2DEXT(target, level, internalformat, x, y, width, height, border);}
  GLEEPFNGLCOPYTEXIMAGE2DEXTPROC GLeeFuncPtr_glCopyTexImage2DEXT=GLee_Lazy_glCopyTexImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTexSubImage1DEXT
#define GLEE_C_DEFINED_glCopyTexSubImage1DEXT
  void __stdcall GLee_Lazy_glCopyTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyTexSubImage1DEXT(target, level, xoffset, x, y, width);}
  GLEEPFNGLCOPYTEXSUBIMAGE1DEXTPROC GLeeFuncPtr_glCopyTexSubImage1DEXT=GLee_Lazy_glCopyTexSubImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTexSubImage2DEXT
#define GLEE_C_DEFINED_glCopyTexSubImage2DEXT
  void __stdcall GLee_Lazy_glCopyTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)  {if (GLeeInit()) glCopyTexSubImage2DEXT(target, level, xoffset, yoffset, x, y, width, height);}
  GLEEPFNGLCOPYTEXSUBIMAGE2DEXTPROC GLeeFuncPtr_glCopyTexSubImage2DEXT=GLee_Lazy_glCopyTexSubImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTexSubImage3DEXT
#define GLEE_C_DEFINED_glCopyTexSubImage3DEXT
  void __stdcall GLee_Lazy_glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)  {if (GLeeInit()) glCopyTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, x, y, width, height);}
  GLEEPFNGLCOPYTEXSUBIMAGE3DEXTPROC GLeeFuncPtr_glCopyTexSubImage3DEXT=GLee_Lazy_glCopyTexSubImage3DEXT;
#endif
#endif

/* GL_EXT_histogram */

#ifdef __GLEE_GL_EXT_histogram
#ifndef GLEE_C_DEFINED_glGetHistogramEXT
#define GLEE_C_DEFINED_glGetHistogramEXT
  void __stdcall GLee_Lazy_glGetHistogramEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)  {if (GLeeInit()) glGetHistogramEXT(target, reset, format, type, values);}
  GLEEPFNGLGETHISTOGRAMEXTPROC GLeeFuncPtr_glGetHistogramEXT=GLee_Lazy_glGetHistogramEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogramParameterfvEXT
#define GLEE_C_DEFINED_glGetHistogramParameterfvEXT
  void __stdcall GLee_Lazy_glGetHistogramParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetHistogramParameterfvEXT(target, pname, params);}
  GLEEPFNGLGETHISTOGRAMPARAMETERFVEXTPROC GLeeFuncPtr_glGetHistogramParameterfvEXT=GLee_Lazy_glGetHistogramParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogramParameterivEXT
#define GLEE_C_DEFINED_glGetHistogramParameterivEXT
  void __stdcall GLee_Lazy_glGetHistogramParameterivEXT(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetHistogramParameterivEXT(target, pname, params);}
  GLEEPFNGLGETHISTOGRAMPARAMETERIVEXTPROC GLeeFuncPtr_glGetHistogramParameterivEXT=GLee_Lazy_glGetHistogramParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmaxEXT
#define GLEE_C_DEFINED_glGetMinmaxEXT
  void __stdcall GLee_Lazy_glGetMinmaxEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)  {if (GLeeInit()) glGetMinmaxEXT(target, reset, format, type, values);}
  GLEEPFNGLGETMINMAXEXTPROC GLeeFuncPtr_glGetMinmaxEXT=GLee_Lazy_glGetMinmaxEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmaxParameterfvEXT
#define GLEE_C_DEFINED_glGetMinmaxParameterfvEXT
  void __stdcall GLee_Lazy_glGetMinmaxParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetMinmaxParameterfvEXT(target, pname, params);}
  GLEEPFNGLGETMINMAXPARAMETERFVEXTPROC GLeeFuncPtr_glGetMinmaxParameterfvEXT=GLee_Lazy_glGetMinmaxParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmaxParameterivEXT
#define GLEE_C_DEFINED_glGetMinmaxParameterivEXT
  void __stdcall GLee_Lazy_glGetMinmaxParameterivEXT(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetMinmaxParameterivEXT(target, pname, params);}
  GLEEPFNGLGETMINMAXPARAMETERIVEXTPROC GLeeFuncPtr_glGetMinmaxParameterivEXT=GLee_Lazy_glGetMinmaxParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glHistogramEXT
#define GLEE_C_DEFINED_glHistogramEXT
  void __stdcall GLee_Lazy_glHistogramEXT(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)  {if (GLeeInit()) glHistogramEXT(target, width, internalformat, sink);}
  GLEEPFNGLHISTOGRAMEXTPROC GLeeFuncPtr_glHistogramEXT=GLee_Lazy_glHistogramEXT;
#endif
#ifndef GLEE_C_DEFINED_glMinmaxEXT
#define GLEE_C_DEFINED_glMinmaxEXT
  void __stdcall GLee_Lazy_glMinmaxEXT(GLenum target, GLenum internalformat, GLboolean sink)  {if (GLeeInit()) glMinmaxEXT(target, internalformat, sink);}
  GLEEPFNGLMINMAXEXTPROC GLeeFuncPtr_glMinmaxEXT=GLee_Lazy_glMinmaxEXT;
#endif
#ifndef GLEE_C_DEFINED_glResetHistogramEXT
#define GLEE_C_DEFINED_glResetHistogramEXT
  void __stdcall GLee_Lazy_glResetHistogramEXT(GLenum target)  {if (GLeeInit()) glResetHistogramEXT(target);}
  GLEEPFNGLRESETHISTOGRAMEXTPROC GLeeFuncPtr_glResetHistogramEXT=GLee_Lazy_glResetHistogramEXT;
#endif
#ifndef GLEE_C_DEFINED_glResetMinmaxEXT
#define GLEE_C_DEFINED_glResetMinmaxEXT
  void __stdcall GLee_Lazy_glResetMinmaxEXT(GLenum target)  {if (GLeeInit()) glResetMinmaxEXT(target);}
  GLEEPFNGLRESETMINMAXEXTPROC GLeeFuncPtr_glResetMinmaxEXT=GLee_Lazy_glResetMinmaxEXT;
#endif
#endif

/* GL_EXT_convolution */

#ifdef __GLEE_GL_EXT_convolution
#ifndef GLEE_C_DEFINED_glConvolutionFilter1DEXT
#define GLEE_C_DEFINED_glConvolutionFilter1DEXT
  void __stdcall GLee_Lazy_glConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)  {if (GLeeInit()) glConvolutionFilter1DEXT(target, internalformat, width, format, type, image);}
  GLEEPFNGLCONVOLUTIONFILTER1DEXTPROC GLeeFuncPtr_glConvolutionFilter1DEXT=GLee_Lazy_glConvolutionFilter1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionFilter2DEXT
#define GLEE_C_DEFINED_glConvolutionFilter2DEXT
  void __stdcall GLee_Lazy_glConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)  {if (GLeeInit()) glConvolutionFilter2DEXT(target, internalformat, width, height, format, type, image);}
  GLEEPFNGLCONVOLUTIONFILTER2DEXTPROC GLeeFuncPtr_glConvolutionFilter2DEXT=GLee_Lazy_glConvolutionFilter2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameterfEXT
#define GLEE_C_DEFINED_glConvolutionParameterfEXT
  void __stdcall GLee_Lazy_glConvolutionParameterfEXT(GLenum target, GLenum pname, GLfloat params)  {if (GLeeInit()) glConvolutionParameterfEXT(target, pname, params);}
  GLEEPFNGLCONVOLUTIONPARAMETERFEXTPROC GLeeFuncPtr_glConvolutionParameterfEXT=GLee_Lazy_glConvolutionParameterfEXT;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameterfvEXT
#define GLEE_C_DEFINED_glConvolutionParameterfvEXT
  void __stdcall GLee_Lazy_glConvolutionParameterfvEXT(GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glConvolutionParameterfvEXT(target, pname, params);}
  GLEEPFNGLCONVOLUTIONPARAMETERFVEXTPROC GLeeFuncPtr_glConvolutionParameterfvEXT=GLee_Lazy_glConvolutionParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameteriEXT
#define GLEE_C_DEFINED_glConvolutionParameteriEXT
  void __stdcall GLee_Lazy_glConvolutionParameteriEXT(GLenum target, GLenum pname, GLint params)  {if (GLeeInit()) glConvolutionParameteriEXT(target, pname, params);}
  GLEEPFNGLCONVOLUTIONPARAMETERIEXTPROC GLeeFuncPtr_glConvolutionParameteriEXT=GLee_Lazy_glConvolutionParameteriEXT;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameterivEXT
#define GLEE_C_DEFINED_glConvolutionParameterivEXT
  void __stdcall GLee_Lazy_glConvolutionParameterivEXT(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glConvolutionParameterivEXT(target, pname, params);}
  GLEEPFNGLCONVOLUTIONPARAMETERIVEXTPROC GLeeFuncPtr_glConvolutionParameterivEXT=GLee_Lazy_glConvolutionParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyConvolutionFilter1DEXT
#define GLEE_C_DEFINED_glCopyConvolutionFilter1DEXT
  void __stdcall GLee_Lazy_glCopyConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyConvolutionFilter1DEXT(target, internalformat, x, y, width);}
  GLEEPFNGLCOPYCONVOLUTIONFILTER1DEXTPROC GLeeFuncPtr_glCopyConvolutionFilter1DEXT=GLee_Lazy_glCopyConvolutionFilter1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyConvolutionFilter2DEXT
#define GLEE_C_DEFINED_glCopyConvolutionFilter2DEXT
  void __stdcall GLee_Lazy_glCopyConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)  {if (GLeeInit()) glCopyConvolutionFilter2DEXT(target, internalformat, x, y, width, height);}
  GLEEPFNGLCOPYCONVOLUTIONFILTER2DEXTPROC GLeeFuncPtr_glCopyConvolutionFilter2DEXT=GLee_Lazy_glCopyConvolutionFilter2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionFilterEXT
#define GLEE_C_DEFINED_glGetConvolutionFilterEXT
  void __stdcall GLee_Lazy_glGetConvolutionFilterEXT(GLenum target, GLenum format, GLenum type, GLvoid * image)  {if (GLeeInit()) glGetConvolutionFilterEXT(target, format, type, image);}
  GLEEPFNGLGETCONVOLUTIONFILTEREXTPROC GLeeFuncPtr_glGetConvolutionFilterEXT=GLee_Lazy_glGetConvolutionFilterEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionParameterfvEXT
#define GLEE_C_DEFINED_glGetConvolutionParameterfvEXT
  void __stdcall GLee_Lazy_glGetConvolutionParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetConvolutionParameterfvEXT(target, pname, params);}
  GLEEPFNGLGETCONVOLUTIONPARAMETERFVEXTPROC GLeeFuncPtr_glGetConvolutionParameterfvEXT=GLee_Lazy_glGetConvolutionParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionParameterivEXT
#define GLEE_C_DEFINED_glGetConvolutionParameterivEXT
  void __stdcall GLee_Lazy_glGetConvolutionParameterivEXT(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetConvolutionParameterivEXT(target, pname, params);}
  GLEEPFNGLGETCONVOLUTIONPARAMETERIVEXTPROC GLeeFuncPtr_glGetConvolutionParameterivEXT=GLee_Lazy_glGetConvolutionParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetSeparableFilterEXT
#define GLEE_C_DEFINED_glGetSeparableFilterEXT
  void __stdcall GLee_Lazy_glGetSeparableFilterEXT(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span)  {if (GLeeInit()) glGetSeparableFilterEXT(target, format, type, row, column, span);}
  GLEEPFNGLGETSEPARABLEFILTEREXTPROC GLeeFuncPtr_glGetSeparableFilterEXT=GLee_Lazy_glGetSeparableFilterEXT;
#endif
#ifndef GLEE_C_DEFINED_glSeparableFilter2DEXT
#define GLEE_C_DEFINED_glSeparableFilter2DEXT
  void __stdcall GLee_Lazy_glSeparableFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column)  {if (GLeeInit()) glSeparableFilter2DEXT(target, internalformat, width, height, format, type, row, column);}
  GLEEPFNGLSEPARABLEFILTER2DEXTPROC GLeeFuncPtr_glSeparableFilter2DEXT=GLee_Lazy_glSeparableFilter2DEXT;
#endif
#endif

/* GL_SGI_color_matrix */

#ifdef __GLEE_GL_SGI_color_matrix
#endif

/* GL_SGI_color_table */

#ifdef __GLEE_GL_SGI_color_table
#ifndef GLEE_C_DEFINED_glColorTableSGI
#define GLEE_C_DEFINED_glColorTableSGI
  void __stdcall GLee_Lazy_glColorTableSGI(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)  {if (GLeeInit()) glColorTableSGI(target, internalformat, width, format, type, table);}
  GLEEPFNGLCOLORTABLESGIPROC GLeeFuncPtr_glColorTableSGI=GLee_Lazy_glColorTableSGI;
#endif
#ifndef GLEE_C_DEFINED_glColorTableParameterfvSGI
#define GLEE_C_DEFINED_glColorTableParameterfvSGI
  void __stdcall GLee_Lazy_glColorTableParameterfvSGI(GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glColorTableParameterfvSGI(target, pname, params);}
  GLEEPFNGLCOLORTABLEPARAMETERFVSGIPROC GLeeFuncPtr_glColorTableParameterfvSGI=GLee_Lazy_glColorTableParameterfvSGI;
#endif
#ifndef GLEE_C_DEFINED_glColorTableParameterivSGI
#define GLEE_C_DEFINED_glColorTableParameterivSGI
  void __stdcall GLee_Lazy_glColorTableParameterivSGI(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glColorTableParameterivSGI(target, pname, params);}
  GLEEPFNGLCOLORTABLEPARAMETERIVSGIPROC GLeeFuncPtr_glColorTableParameterivSGI=GLee_Lazy_glColorTableParameterivSGI;
#endif
#ifndef GLEE_C_DEFINED_glCopyColorTableSGI
#define GLEE_C_DEFINED_glCopyColorTableSGI
  void __stdcall GLee_Lazy_glCopyColorTableSGI(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyColorTableSGI(target, internalformat, x, y, width);}
  GLEEPFNGLCOPYCOLORTABLESGIPROC GLeeFuncPtr_glCopyColorTableSGI=GLee_Lazy_glCopyColorTableSGI;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableSGI
#define GLEE_C_DEFINED_glGetColorTableSGI
  void __stdcall GLee_Lazy_glGetColorTableSGI(GLenum target, GLenum format, GLenum type, GLvoid * table)  {if (GLeeInit()) glGetColorTableSGI(target, format, type, table);}
  GLEEPFNGLGETCOLORTABLESGIPROC GLeeFuncPtr_glGetColorTableSGI=GLee_Lazy_glGetColorTableSGI;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableParameterfvSGI
#define GLEE_C_DEFINED_glGetColorTableParameterfvSGI
  void __stdcall GLee_Lazy_glGetColorTableParameterfvSGI(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetColorTableParameterfvSGI(target, pname, params);}
  GLEEPFNGLGETCOLORTABLEPARAMETERFVSGIPROC GLeeFuncPtr_glGetColorTableParameterfvSGI=GLee_Lazy_glGetColorTableParameterfvSGI;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableParameterivSGI
#define GLEE_C_DEFINED_glGetColorTableParameterivSGI
  void __stdcall GLee_Lazy_glGetColorTableParameterivSGI(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetColorTableParameterivSGI(target, pname, params);}
  GLEEPFNGLGETCOLORTABLEPARAMETERIVSGIPROC GLeeFuncPtr_glGetColorTableParameterivSGI=GLee_Lazy_glGetColorTableParameterivSGI;
#endif
#endif

/* GL_SGIS_pixel_texture */

#ifdef __GLEE_GL_SGIS_pixel_texture
#ifndef GLEE_C_DEFINED_glPixelTexGenParameteriSGIS
#define GLEE_C_DEFINED_glPixelTexGenParameteriSGIS
  void __stdcall GLee_Lazy_glPixelTexGenParameteriSGIS(GLenum pname, GLint param)  {if (GLeeInit()) glPixelTexGenParameteriSGIS(pname, param);}
  GLEEPFNGLPIXELTEXGENPARAMETERISGISPROC GLeeFuncPtr_glPixelTexGenParameteriSGIS=GLee_Lazy_glPixelTexGenParameteriSGIS;
#endif
#ifndef GLEE_C_DEFINED_glPixelTexGenParameterivSGIS
#define GLEE_C_DEFINED_glPixelTexGenParameterivSGIS
  void __stdcall GLee_Lazy_glPixelTexGenParameterivSGIS(GLenum pname, const GLint * params)  {if (GLeeInit()) glPixelTexGenParameterivSGIS(pname, params);}
  GLEEPFNGLPIXELTEXGENPARAMETERIVSGISPROC GLeeFuncPtr_glPixelTexGenParameterivSGIS=GLee_Lazy_glPixelTexGenParameterivSGIS;
#endif
#ifndef GLEE_C_DEFINED_glPixelTexGenParameterfSGIS
#define GLEE_C_DEFINED_glPixelTexGenParameterfSGIS
  void __stdcall GLee_Lazy_glPixelTexGenParameterfSGIS(GLenum pname, GLfloat param)  {if (GLeeInit()) glPixelTexGenParameterfSGIS(pname, param);}
  GLEEPFNGLPIXELTEXGENPARAMETERFSGISPROC GLeeFuncPtr_glPixelTexGenParameterfSGIS=GLee_Lazy_glPixelTexGenParameterfSGIS;
#endif
#ifndef GLEE_C_DEFINED_glPixelTexGenParameterfvSGIS
#define GLEE_C_DEFINED_glPixelTexGenParameterfvSGIS
  void __stdcall GLee_Lazy_glPixelTexGenParameterfvSGIS(GLenum pname, const GLfloat * params)  {if (GLeeInit()) glPixelTexGenParameterfvSGIS(pname, params);}
  GLEEPFNGLPIXELTEXGENPARAMETERFVSGISPROC GLeeFuncPtr_glPixelTexGenParameterfvSGIS=GLee_Lazy_glPixelTexGenParameterfvSGIS;
#endif
#ifndef GLEE_C_DEFINED_glGetPixelTexGenParameterivSGIS
#define GLEE_C_DEFINED_glGetPixelTexGenParameterivSGIS
  void __stdcall GLee_Lazy_glGetPixelTexGenParameterivSGIS(GLenum pname, GLint * params)  {if (GLeeInit()) glGetPixelTexGenParameterivSGIS(pname, params);}
  GLEEPFNGLGETPIXELTEXGENPARAMETERIVSGISPROC GLeeFuncPtr_glGetPixelTexGenParameterivSGIS=GLee_Lazy_glGetPixelTexGenParameterivSGIS;
#endif
#ifndef GLEE_C_DEFINED_glGetPixelTexGenParameterfvSGIS
#define GLEE_C_DEFINED_glGetPixelTexGenParameterfvSGIS
  void __stdcall GLee_Lazy_glGetPixelTexGenParameterfvSGIS(GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetPixelTexGenParameterfvSGIS(pname, params);}
  GLEEPFNGLGETPIXELTEXGENPARAMETERFVSGISPROC GLeeFuncPtr_glGetPixelTexGenParameterfvSGIS=GLee_Lazy_glGetPixelTexGenParameterfvSGIS;
#endif
#endif

/* GL_SGIX_pixel_texture */

#ifdef __GLEE_GL_SGIX_pixel_texture
#ifndef GLEE_C_DEFINED_glPixelTexGenSGIX
#define GLEE_C_DEFINED_glPixelTexGenSGIX
  void __stdcall GLee_Lazy_glPixelTexGenSGIX(GLenum mode)  {if (GLeeInit()) glPixelTexGenSGIX(mode);}
  GLEEPFNGLPIXELTEXGENSGIXPROC GLeeFuncPtr_glPixelTexGenSGIX=GLee_Lazy_glPixelTexGenSGIX;
#endif
#endif

/* GL_SGIS_texture4D */

#ifdef __GLEE_GL_SGIS_texture4D
#ifndef GLEE_C_DEFINED_glTexImage4DSGIS
#define GLEE_C_DEFINED_glTexImage4DSGIS
  void __stdcall GLee_Lazy_glTexImage4DSGIS(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexImage4DSGIS(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels);}
  GLEEPFNGLTEXIMAGE4DSGISPROC GLeeFuncPtr_glTexImage4DSGIS=GLee_Lazy_glTexImage4DSGIS;
#endif
#ifndef GLEE_C_DEFINED_glTexSubImage4DSGIS
#define GLEE_C_DEFINED_glTexSubImage4DSGIS
  void __stdcall GLee_Lazy_glTexSubImage4DSGIS(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexSubImage4DSGIS(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels);}
  GLEEPFNGLTEXSUBIMAGE4DSGISPROC GLeeFuncPtr_glTexSubImage4DSGIS=GLee_Lazy_glTexSubImage4DSGIS;
#endif
#endif

/* GL_SGI_texture_color_table */

#ifdef __GLEE_GL_SGI_texture_color_table
#endif

/* GL_EXT_cmyka */

#ifdef __GLEE_GL_EXT_cmyka
#endif

/* GL_EXT_texture_object */

#ifdef __GLEE_GL_EXT_texture_object
#ifndef GLEE_C_DEFINED_glAreTexturesResidentEXT
#define GLEE_C_DEFINED_glAreTexturesResidentEXT
  GLboolean __stdcall GLee_Lazy_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences)  {if (GLeeInit()) return glAreTexturesResidentEXT(n, textures, residences); return (GLboolean)0;}
  GLEEPFNGLARETEXTURESRESIDENTEXTPROC GLeeFuncPtr_glAreTexturesResidentEXT=GLee_Lazy_glAreTexturesResidentEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindTextureEXT
#define GLEE_C_DEFINED_glBindTextureEXT
  void __stdcall GLee_Lazy_glBindTextureEXT(GLenum target, GLuint texture)  {if (GLeeInit()) glBindTextureEXT(target, texture);}
  GLEEPFNGLBINDTEXTUREEXTPROC GLeeFuncPtr_glBindTextureEXT=GLee_Lazy_glBindTextureEXT;
#endif
#ifndef GLEE_C_DEFINED_glDeleteTexturesEXT
#define GLEE_C_DEFINED_glDeleteTexturesEXT
  void __stdcall GLee_Lazy_glDeleteTexturesEXT(GLsizei n, const GLuint * textures)  {if (GLeeInit()) glDeleteTexturesEXT(n, textures);}
  GLEEPFNGLDELETETEXTURESEXTPROC GLeeFuncPtr_glDeleteTexturesEXT=GLee_Lazy_glDeleteTexturesEXT;
#endif
#ifndef GLEE_C_DEFINED_glGenTexturesEXT
#define GLEE_C_DEFINED_glGenTexturesEXT
  void __stdcall GLee_Lazy_glGenTexturesEXT(GLsizei n, GLuint * textures)  {if (GLeeInit()) glGenTexturesEXT(n, textures);}
  GLEEPFNGLGENTEXTURESEXTPROC GLeeFuncPtr_glGenTexturesEXT=GLee_Lazy_glGenTexturesEXT;
#endif
#ifndef GLEE_C_DEFINED_glIsTextureEXT
#define GLEE_C_DEFINED_glIsTextureEXT
  GLboolean __stdcall GLee_Lazy_glIsTextureEXT(GLuint texture)  {if (GLeeInit()) return glIsTextureEXT(texture); return (GLboolean)0;}
  GLEEPFNGLISTEXTUREEXTPROC GLeeFuncPtr_glIsTextureEXT=GLee_Lazy_glIsTextureEXT;
#endif
#ifndef GLEE_C_DEFINED_glPrioritizeTexturesEXT
#define GLEE_C_DEFINED_glPrioritizeTexturesEXT
  void __stdcall GLee_Lazy_glPrioritizeTexturesEXT(GLsizei n, const GLuint * textures, const GLclampf * priorities)  {if (GLeeInit()) glPrioritizeTexturesEXT(n, textures, priorities);}
  GLEEPFNGLPRIORITIZETEXTURESEXTPROC GLeeFuncPtr_glPrioritizeTexturesEXT=GLee_Lazy_glPrioritizeTexturesEXT;
#endif
#endif

/* GL_SGIS_detail_texture */

#ifdef __GLEE_GL_SGIS_detail_texture
#ifndef GLEE_C_DEFINED_glDetailTexFuncSGIS
#define GLEE_C_DEFINED_glDetailTexFuncSGIS
  void __stdcall GLee_Lazy_glDetailTexFuncSGIS(GLenum target, GLsizei n, const GLfloat * points)  {if (GLeeInit()) glDetailTexFuncSGIS(target, n, points);}
  GLEEPFNGLDETAILTEXFUNCSGISPROC GLeeFuncPtr_glDetailTexFuncSGIS=GLee_Lazy_glDetailTexFuncSGIS;
#endif
#ifndef GLEE_C_DEFINED_glGetDetailTexFuncSGIS
#define GLEE_C_DEFINED_glGetDetailTexFuncSGIS
  void __stdcall GLee_Lazy_glGetDetailTexFuncSGIS(GLenum target, GLfloat * points)  {if (GLeeInit()) glGetDetailTexFuncSGIS(target, points);}
  GLEEPFNGLGETDETAILTEXFUNCSGISPROC GLeeFuncPtr_glGetDetailTexFuncSGIS=GLee_Lazy_glGetDetailTexFuncSGIS;
#endif
#endif

/* GL_SGIS_sharpen_texture */

#ifdef __GLEE_GL_SGIS_sharpen_texture
#ifndef GLEE_C_DEFINED_glSharpenTexFuncSGIS
#define GLEE_C_DEFINED_glSharpenTexFuncSGIS
  void __stdcall GLee_Lazy_glSharpenTexFuncSGIS(GLenum target, GLsizei n, const GLfloat * points)  {if (GLeeInit()) glSharpenTexFuncSGIS(target, n, points);}
  GLEEPFNGLSHARPENTEXFUNCSGISPROC GLeeFuncPtr_glSharpenTexFuncSGIS=GLee_Lazy_glSharpenTexFuncSGIS;
#endif
#ifndef GLEE_C_DEFINED_glGetSharpenTexFuncSGIS
#define GLEE_C_DEFINED_glGetSharpenTexFuncSGIS
  void __stdcall GLee_Lazy_glGetSharpenTexFuncSGIS(GLenum target, GLfloat * points)  {if (GLeeInit()) glGetSharpenTexFuncSGIS(target, points);}
  GLEEPFNGLGETSHARPENTEXFUNCSGISPROC GLeeFuncPtr_glGetSharpenTexFuncSGIS=GLee_Lazy_glGetSharpenTexFuncSGIS;
#endif
#endif

/* GL_EXT_packed_pixels */

#ifdef __GLEE_GL_EXT_packed_pixels
#endif

/* GL_SGIS_texture_lod */

#ifdef __GLEE_GL_SGIS_texture_lod
#endif

/* GL_SGIS_multisample */

#ifdef __GLEE_GL_SGIS_multisample
#ifndef GLEE_C_DEFINED_glSampleMaskSGIS
#define GLEE_C_DEFINED_glSampleMaskSGIS
  void __stdcall GLee_Lazy_glSampleMaskSGIS(GLclampf value, GLboolean invert)  {if (GLeeInit()) glSampleMaskSGIS(value, invert);}
  GLEEPFNGLSAMPLEMASKSGISPROC GLeeFuncPtr_glSampleMaskSGIS=GLee_Lazy_glSampleMaskSGIS;
#endif
#ifndef GLEE_C_DEFINED_glSamplePatternSGIS
#define GLEE_C_DEFINED_glSamplePatternSGIS
  void __stdcall GLee_Lazy_glSamplePatternSGIS(GLenum pattern)  {if (GLeeInit()) glSamplePatternSGIS(pattern);}
  GLEEPFNGLSAMPLEPATTERNSGISPROC GLeeFuncPtr_glSamplePatternSGIS=GLee_Lazy_glSamplePatternSGIS;
#endif
#endif

/* GL_EXT_rescale_normal */

#ifdef __GLEE_GL_EXT_rescale_normal
#endif

/* GL_EXT_vertex_array */

#ifdef __GLEE_GL_EXT_vertex_array
#ifndef GLEE_C_DEFINED_glArrayElementEXT
#define GLEE_C_DEFINED_glArrayElementEXT
  void __stdcall GLee_Lazy_glArrayElementEXT(GLint i)  {if (GLeeInit()) glArrayElementEXT(i);}
  GLEEPFNGLARRAYELEMENTEXTPROC GLeeFuncPtr_glArrayElementEXT=GLee_Lazy_glArrayElementEXT;
#endif
#ifndef GLEE_C_DEFINED_glColorPointerEXT
#define GLEE_C_DEFINED_glColorPointerEXT
  void __stdcall GLee_Lazy_glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)  {if (GLeeInit()) glColorPointerEXT(size, type, stride, count, pointer);}
  GLEEPFNGLCOLORPOINTEREXTPROC GLeeFuncPtr_glColorPointerEXT=GLee_Lazy_glColorPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glDrawArraysEXT
#define GLEE_C_DEFINED_glDrawArraysEXT
  void __stdcall GLee_Lazy_glDrawArraysEXT(GLenum mode, GLint first, GLsizei count)  {if (GLeeInit()) glDrawArraysEXT(mode, first, count);}
  GLEEPFNGLDRAWARRAYSEXTPROC GLeeFuncPtr_glDrawArraysEXT=GLee_Lazy_glDrawArraysEXT;
#endif
#ifndef GLEE_C_DEFINED_glEdgeFlagPointerEXT
#define GLEE_C_DEFINED_glEdgeFlagPointerEXT
  void __stdcall GLee_Lazy_glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean * pointer)  {if (GLeeInit()) glEdgeFlagPointerEXT(stride, count, pointer);}
  GLEEPFNGLEDGEFLAGPOINTEREXTPROC GLeeFuncPtr_glEdgeFlagPointerEXT=GLee_Lazy_glEdgeFlagPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetPointervEXT
#define GLEE_C_DEFINED_glGetPointervEXT
  void __stdcall GLee_Lazy_glGetPointervEXT(GLenum pname, GLvoid* * params)  {if (GLeeInit()) glGetPointervEXT(pname, params);}
  GLEEPFNGLGETPOINTERVEXTPROC GLeeFuncPtr_glGetPointervEXT=GLee_Lazy_glGetPointervEXT;
#endif
#ifndef GLEE_C_DEFINED_glIndexPointerEXT
#define GLEE_C_DEFINED_glIndexPointerEXT
  void __stdcall GLee_Lazy_glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)  {if (GLeeInit()) glIndexPointerEXT(type, stride, count, pointer);}
  GLEEPFNGLINDEXPOINTEREXTPROC GLeeFuncPtr_glIndexPointerEXT=GLee_Lazy_glIndexPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glNormalPointerEXT
#define GLEE_C_DEFINED_glNormalPointerEXT
  void __stdcall GLee_Lazy_glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)  {if (GLeeInit()) glNormalPointerEXT(type, stride, count, pointer);}
  GLEEPFNGLNORMALPOINTEREXTPROC GLeeFuncPtr_glNormalPointerEXT=GLee_Lazy_glNormalPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glTexCoordPointerEXT
#define GLEE_C_DEFINED_glTexCoordPointerEXT
  void __stdcall GLee_Lazy_glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)  {if (GLeeInit()) glTexCoordPointerEXT(size, type, stride, count, pointer);}
  GLEEPFNGLTEXCOORDPOINTEREXTPROC GLeeFuncPtr_glTexCoordPointerEXT=GLee_Lazy_glTexCoordPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexPointerEXT
#define GLEE_C_DEFINED_glVertexPointerEXT
  void __stdcall GLee_Lazy_glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)  {if (GLeeInit()) glVertexPointerEXT(size, type, stride, count, pointer);}
  GLEEPFNGLVERTEXPOINTEREXTPROC GLeeFuncPtr_glVertexPointerEXT=GLee_Lazy_glVertexPointerEXT;
#endif
#endif

/* GL_EXT_misc_attribute */

#ifdef __GLEE_GL_EXT_misc_attribute
#endif

/* GL_SGIS_generate_mipmap */

#ifdef __GLEE_GL_SGIS_generate_mipmap
#endif

/* GL_SGIX_clipmap */

#ifdef __GLEE_GL_SGIX_clipmap
#endif

/* GL_SGIX_shadow */

#ifdef __GLEE_GL_SGIX_shadow
#endif

/* GL_SGIS_texture_edge_clamp */

#ifdef __GLEE_GL_SGIS_texture_edge_clamp
#endif

/* GL_SGIS_texture_border_clamp */

#ifdef __GLEE_GL_SGIS_texture_border_clamp
#endif

/* GL_EXT_blend_minmax */

#ifdef __GLEE_GL_EXT_blend_minmax
#ifndef GLEE_C_DEFINED_glBlendEquationEXT
#define GLEE_C_DEFINED_glBlendEquationEXT
  void __stdcall GLee_Lazy_glBlendEquationEXT(GLenum mode)  {if (GLeeInit()) glBlendEquationEXT(mode);}
  GLEEPFNGLBLENDEQUATIONEXTPROC GLeeFuncPtr_glBlendEquationEXT=GLee_Lazy_glBlendEquationEXT;
#endif
#endif

/* GL_EXT_blend_subtract */

#ifdef __GLEE_GL_EXT_blend_subtract
#endif

/* GL_EXT_blend_logic_op */

#ifdef __GLEE_GL_EXT_blend_logic_op
#endif

/* GL_SGIX_interlace */

#ifdef __GLEE_GL_SGIX_interlace
#endif

/* GL_SGIX_pixel_tiles */

#ifdef __GLEE_GL_SGIX_pixel_tiles
#endif

/* GL_SGIS_texture_select */

#ifdef __GLEE_GL_SGIS_texture_select
#endif

/* GL_SGIX_sprite */

#ifdef __GLEE_GL_SGIX_sprite
#ifndef GLEE_C_DEFINED_glSpriteParameterfSGIX
#define GLEE_C_DEFINED_glSpriteParameterfSGIX
  void __stdcall GLee_Lazy_glSpriteParameterfSGIX(GLenum pname, GLfloat param)  {if (GLeeInit()) glSpriteParameterfSGIX(pname, param);}
  GLEEPFNGLSPRITEPARAMETERFSGIXPROC GLeeFuncPtr_glSpriteParameterfSGIX=GLee_Lazy_glSpriteParameterfSGIX;
#endif
#ifndef GLEE_C_DEFINED_glSpriteParameterfvSGIX
#define GLEE_C_DEFINED_glSpriteParameterfvSGIX
  void __stdcall GLee_Lazy_glSpriteParameterfvSGIX(GLenum pname, const GLfloat * params)  {if (GLeeInit()) glSpriteParameterfvSGIX(pname, params);}
  GLEEPFNGLSPRITEPARAMETERFVSGIXPROC GLeeFuncPtr_glSpriteParameterfvSGIX=GLee_Lazy_glSpriteParameterfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glSpriteParameteriSGIX
#define GLEE_C_DEFINED_glSpriteParameteriSGIX
  void __stdcall GLee_Lazy_glSpriteParameteriSGIX(GLenum pname, GLint param)  {if (GLeeInit()) glSpriteParameteriSGIX(pname, param);}
  GLEEPFNGLSPRITEPARAMETERISGIXPROC GLeeFuncPtr_glSpriteParameteriSGIX=GLee_Lazy_glSpriteParameteriSGIX;
#endif
#ifndef GLEE_C_DEFINED_glSpriteParameterivSGIX
#define GLEE_C_DEFINED_glSpriteParameterivSGIX
  void __stdcall GLee_Lazy_glSpriteParameterivSGIX(GLenum pname, const GLint * params)  {if (GLeeInit()) glSpriteParameterivSGIX(pname, params);}
  GLEEPFNGLSPRITEPARAMETERIVSGIXPROC GLeeFuncPtr_glSpriteParameterivSGIX=GLee_Lazy_glSpriteParameterivSGIX;
#endif
#endif

/* GL_SGIX_texture_multi_buffer */

#ifdef __GLEE_GL_SGIX_texture_multi_buffer
#endif

/* GL_EXT_point_parameters */

#ifdef __GLEE_GL_EXT_point_parameters
#ifndef GLEE_C_DEFINED_glPointParameterfEXT
#define GLEE_C_DEFINED_glPointParameterfEXT
  void __stdcall GLee_Lazy_glPointParameterfEXT(GLenum pname, GLfloat param)  {if (GLeeInit()) glPointParameterfEXT(pname, param);}
  GLEEPFNGLPOINTPARAMETERFEXTPROC GLeeFuncPtr_glPointParameterfEXT=GLee_Lazy_glPointParameterfEXT;
#endif
#ifndef GLEE_C_DEFINED_glPointParameterfvEXT
#define GLEE_C_DEFINED_glPointParameterfvEXT
  void __stdcall GLee_Lazy_glPointParameterfvEXT(GLenum pname, const GLfloat * params)  {if (GLeeInit()) glPointParameterfvEXT(pname, params);}
  GLEEPFNGLPOINTPARAMETERFVEXTPROC GLeeFuncPtr_glPointParameterfvEXT=GLee_Lazy_glPointParameterfvEXT;
#endif
#endif

/* GL_SGIS_point_parameters */

#ifdef __GLEE_GL_SGIS_point_parameters
#ifndef GLEE_C_DEFINED_glPointParameterfSGIS
#define GLEE_C_DEFINED_glPointParameterfSGIS
  void __stdcall GLee_Lazy_glPointParameterfSGIS(GLenum pname, GLfloat param)  {if (GLeeInit()) glPointParameterfSGIS(pname, param);}
  GLEEPFNGLPOINTPARAMETERFSGISPROC GLeeFuncPtr_glPointParameterfSGIS=GLee_Lazy_glPointParameterfSGIS;
#endif
#ifndef GLEE_C_DEFINED_glPointParameterfvSGIS
#define GLEE_C_DEFINED_glPointParameterfvSGIS
  void __stdcall GLee_Lazy_glPointParameterfvSGIS(GLenum pname, const GLfloat * params)  {if (GLeeInit()) glPointParameterfvSGIS(pname, params);}
  GLEEPFNGLPOINTPARAMETERFVSGISPROC GLeeFuncPtr_glPointParameterfvSGIS=GLee_Lazy_glPointParameterfvSGIS;
#endif
#endif

/* GL_SGIX_instruments */

#ifdef __GLEE_GL_SGIX_instruments
#ifndef GLEE_C_DEFINED_glGetInstrumentsSGIX
#define GLEE_C_DEFINED_glGetInstrumentsSGIX
  GLint __stdcall GLee_Lazy_glGetInstrumentsSGIX(void)  {if (GLeeInit()) return glGetInstrumentsSGIX(); return (GLint)0;}
  GLEEPFNGLGETINSTRUMENTSSGIXPROC GLeeFuncPtr_glGetInstrumentsSGIX=GLee_Lazy_glGetInstrumentsSGIX;
#endif
#ifndef GLEE_C_DEFINED_glInstrumentsBufferSGIX
#define GLEE_C_DEFINED_glInstrumentsBufferSGIX
  void __stdcall GLee_Lazy_glInstrumentsBufferSGIX(GLsizei size, GLint * buffer)  {if (GLeeInit()) glInstrumentsBufferSGIX(size, buffer);}
  GLEEPFNGLINSTRUMENTSBUFFERSGIXPROC GLeeFuncPtr_glInstrumentsBufferSGIX=GLee_Lazy_glInstrumentsBufferSGIX;
#endif
#ifndef GLEE_C_DEFINED_glPollInstrumentsSGIX
#define GLEE_C_DEFINED_glPollInstrumentsSGIX
  GLint __stdcall GLee_Lazy_glPollInstrumentsSGIX(GLint * marker_p)  {if (GLeeInit()) return glPollInstrumentsSGIX(marker_p); return (GLint)0;}
  GLEEPFNGLPOLLINSTRUMENTSSGIXPROC GLeeFuncPtr_glPollInstrumentsSGIX=GLee_Lazy_glPollInstrumentsSGIX;
#endif
#ifndef GLEE_C_DEFINED_glReadInstrumentsSGIX
#define GLEE_C_DEFINED_glReadInstrumentsSGIX
  void __stdcall GLee_Lazy_glReadInstrumentsSGIX(GLint marker)  {if (GLeeInit()) glReadInstrumentsSGIX(marker);}
  GLEEPFNGLREADINSTRUMENTSSGIXPROC GLeeFuncPtr_glReadInstrumentsSGIX=GLee_Lazy_glReadInstrumentsSGIX;
#endif
#ifndef GLEE_C_DEFINED_glStartInstrumentsSGIX
#define GLEE_C_DEFINED_glStartInstrumentsSGIX
  void __stdcall GLee_Lazy_glStartInstrumentsSGIX(void)  {if (GLeeInit()) glStartInstrumentsSGIX();}
  GLEEPFNGLSTARTINSTRUMENTSSGIXPROC GLeeFuncPtr_glStartInstrumentsSGIX=GLee_Lazy_glStartInstrumentsSGIX;
#endif
#ifndef GLEE_C_DEFINED_glStopInstrumentsSGIX
#define GLEE_C_DEFINED_glStopInstrumentsSGIX
  void __stdcall GLee_Lazy_glStopInstrumentsSGIX(GLint marker)  {if (GLeeInit()) glStopInstrumentsSGIX(marker);}
  GLEEPFNGLSTOPINSTRUMENTSSGIXPROC GLeeFuncPtr_glStopInstrumentsSGIX=GLee_Lazy_glStopInstrumentsSGIX;
#endif
#endif

/* GL_SGIX_texture_scale_bias */

#ifdef __GLEE_GL_SGIX_texture_scale_bias
#endif

/* GL_SGIX_framezoom */

#ifdef __GLEE_GL_SGIX_framezoom
#ifndef GLEE_C_DEFINED_glFrameZoomSGIX
#define GLEE_C_DEFINED_glFrameZoomSGIX
  void __stdcall GLee_Lazy_glFrameZoomSGIX(GLint factor)  {if (GLeeInit()) glFrameZoomSGIX(factor);}
  GLEEPFNGLFRAMEZOOMSGIXPROC GLeeFuncPtr_glFrameZoomSGIX=GLee_Lazy_glFrameZoomSGIX;
#endif
#endif

/* GL_SGIX_tag_sample_buffer */

#ifdef __GLEE_GL_SGIX_tag_sample_buffer
#ifndef GLEE_C_DEFINED_glTagSampleBufferSGIX
#define GLEE_C_DEFINED_glTagSampleBufferSGIX
  void __stdcall GLee_Lazy_glTagSampleBufferSGIX(void)  {if (GLeeInit()) glTagSampleBufferSGIX();}
  GLEEPFNGLTAGSAMPLEBUFFERSGIXPROC GLeeFuncPtr_glTagSampleBufferSGIX=GLee_Lazy_glTagSampleBufferSGIX;
#endif
#endif

/* GL_FfdMaskSGIX */

#ifdef __GLEE_GL_FfdMaskSGIX
#endif

/* GL_SGIX_polynomial_ffd */

#ifdef __GLEE_GL_SGIX_polynomial_ffd
#ifndef GLEE_C_DEFINED_glDeformationMap3dSGIX
#define GLEE_C_DEFINED_glDeformationMap3dSGIX
  void __stdcall GLee_Lazy_glDeformationMap3dSGIX(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble * points)  {if (GLeeInit()) glDeformationMap3dSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);}
  GLEEPFNGLDEFORMATIONMAP3DSGIXPROC GLeeFuncPtr_glDeformationMap3dSGIX=GLee_Lazy_glDeformationMap3dSGIX;
#endif
#ifndef GLEE_C_DEFINED_glDeformationMap3fSGIX
#define GLEE_C_DEFINED_glDeformationMap3fSGIX
  void __stdcall GLee_Lazy_glDeformationMap3fSGIX(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat * points)  {if (GLeeInit()) glDeformationMap3fSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);}
  GLEEPFNGLDEFORMATIONMAP3FSGIXPROC GLeeFuncPtr_glDeformationMap3fSGIX=GLee_Lazy_glDeformationMap3fSGIX;
#endif
#ifndef GLEE_C_DEFINED_glDeformSGIX
#define GLEE_C_DEFINED_glDeformSGIX
  void __stdcall GLee_Lazy_glDeformSGIX(GLbitfield mask)  {if (GLeeInit()) glDeformSGIX(mask);}
  GLEEPFNGLDEFORMSGIXPROC GLeeFuncPtr_glDeformSGIX=GLee_Lazy_glDeformSGIX;
#endif
#ifndef GLEE_C_DEFINED_glLoadIdentityDeformationMapSGIX
#define GLEE_C_DEFINED_glLoadIdentityDeformationMapSGIX
  void __stdcall GLee_Lazy_glLoadIdentityDeformationMapSGIX(GLbitfield mask)  {if (GLeeInit()) glLoadIdentityDeformationMapSGIX(mask);}
  GLEEPFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC GLeeFuncPtr_glLoadIdentityDeformationMapSGIX=GLee_Lazy_glLoadIdentityDeformationMapSGIX;
#endif
#endif

/* GL_SGIX_reference_plane */

#ifdef __GLEE_GL_SGIX_reference_plane
#ifndef GLEE_C_DEFINED_glReferencePlaneSGIX
#define GLEE_C_DEFINED_glReferencePlaneSGIX
  void __stdcall GLee_Lazy_glReferencePlaneSGIX(const GLdouble * equation)  {if (GLeeInit()) glReferencePlaneSGIX(equation);}
  GLEEPFNGLREFERENCEPLANESGIXPROC GLeeFuncPtr_glReferencePlaneSGIX=GLee_Lazy_glReferencePlaneSGIX;
#endif
#endif

/* GL_SGIX_flush_raster */

#ifdef __GLEE_GL_SGIX_flush_raster
#ifndef GLEE_C_DEFINED_glFlushRasterSGIX
#define GLEE_C_DEFINED_glFlushRasterSGIX
  void __stdcall GLee_Lazy_glFlushRasterSGIX(void)  {if (GLeeInit()) glFlushRasterSGIX();}
  GLEEPFNGLFLUSHRASTERSGIXPROC GLeeFuncPtr_glFlushRasterSGIX=GLee_Lazy_glFlushRasterSGIX;
#endif
#endif

/* GL_SGIX_depth_texture */

#ifdef __GLEE_GL_SGIX_depth_texture
#endif

/* GL_SGIS_fog_function */

#ifdef __GLEE_GL_SGIS_fog_function
#ifndef GLEE_C_DEFINED_glFogFuncSGIS
#define GLEE_C_DEFINED_glFogFuncSGIS
  void __stdcall GLee_Lazy_glFogFuncSGIS(GLsizei n, const GLfloat * points)  {if (GLeeInit()) glFogFuncSGIS(n, points);}
  GLEEPFNGLFOGFUNCSGISPROC GLeeFuncPtr_glFogFuncSGIS=GLee_Lazy_glFogFuncSGIS;
#endif
#ifndef GLEE_C_DEFINED_glGetFogFuncSGIS
#define GLEE_C_DEFINED_glGetFogFuncSGIS
  void __stdcall GLee_Lazy_glGetFogFuncSGIS(GLfloat * points)  {if (GLeeInit()) glGetFogFuncSGIS(points);}
  GLEEPFNGLGETFOGFUNCSGISPROC GLeeFuncPtr_glGetFogFuncSGIS=GLee_Lazy_glGetFogFuncSGIS;
#endif
#endif

/* GL_SGIX_fog_offset */

#ifdef __GLEE_GL_SGIX_fog_offset
#endif

/* GL_HP_image_transform */

#ifdef __GLEE_GL_HP_image_transform
#ifndef GLEE_C_DEFINED_glImageTransformParameteriHP
#define GLEE_C_DEFINED_glImageTransformParameteriHP
  void __stdcall GLee_Lazy_glImageTransformParameteriHP(GLenum target, GLenum pname, GLint param)  {if (GLeeInit()) glImageTransformParameteriHP(target, pname, param);}
  GLEEPFNGLIMAGETRANSFORMPARAMETERIHPPROC GLeeFuncPtr_glImageTransformParameteriHP=GLee_Lazy_glImageTransformParameteriHP;
#endif
#ifndef GLEE_C_DEFINED_glImageTransformParameterfHP
#define GLEE_C_DEFINED_glImageTransformParameterfHP
  void __stdcall GLee_Lazy_glImageTransformParameterfHP(GLenum target, GLenum pname, GLfloat param)  {if (GLeeInit()) glImageTransformParameterfHP(target, pname, param);}
  GLEEPFNGLIMAGETRANSFORMPARAMETERFHPPROC GLeeFuncPtr_glImageTransformParameterfHP=GLee_Lazy_glImageTransformParameterfHP;
#endif
#ifndef GLEE_C_DEFINED_glImageTransformParameterivHP
#define GLEE_C_DEFINED_glImageTransformParameterivHP
  void __stdcall GLee_Lazy_glImageTransformParameterivHP(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glImageTransformParameterivHP(target, pname, params);}
  GLEEPFNGLIMAGETRANSFORMPARAMETERIVHPPROC GLeeFuncPtr_glImageTransformParameterivHP=GLee_Lazy_glImageTransformParameterivHP;
#endif
#ifndef GLEE_C_DEFINED_glImageTransformParameterfvHP
#define GLEE_C_DEFINED_glImageTransformParameterfvHP
  void __stdcall GLee_Lazy_glImageTransformParameterfvHP(GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glImageTransformParameterfvHP(target, pname, params);}
  GLEEPFNGLIMAGETRANSFORMPARAMETERFVHPPROC GLeeFuncPtr_glImageTransformParameterfvHP=GLee_Lazy_glImageTransformParameterfvHP;
#endif
#ifndef GLEE_C_DEFINED_glGetImageTransformParameterivHP
#define GLEE_C_DEFINED_glGetImageTransformParameterivHP
  void __stdcall GLee_Lazy_glGetImageTransformParameterivHP(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetImageTransformParameterivHP(target, pname, params);}
  GLEEPFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC GLeeFuncPtr_glGetImageTransformParameterivHP=GLee_Lazy_glGetImageTransformParameterivHP;
#endif
#ifndef GLEE_C_DEFINED_glGetImageTransformParameterfvHP
#define GLEE_C_DEFINED_glGetImageTransformParameterfvHP
  void __stdcall GLee_Lazy_glGetImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetImageTransformParameterfvHP(target, pname, params);}
  GLEEPFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC GLeeFuncPtr_glGetImageTransformParameterfvHP=GLee_Lazy_glGetImageTransformParameterfvHP;
#endif
#endif

/* GL_HP_convolution_border_modes */

#ifdef __GLEE_GL_HP_convolution_border_modes
#endif

/* GL_INGR_palette_buffer */

#ifdef __GLEE_GL_INGR_palette_buffer
#endif

/* GL_SGIX_texture_add_env */

#ifdef __GLEE_GL_SGIX_texture_add_env
#endif

/* GL_EXT_color_subtable */

#ifdef __GLEE_GL_EXT_color_subtable
#ifndef GLEE_C_DEFINED_glColorSubTableEXT
#define GLEE_C_DEFINED_glColorSubTableEXT
  void __stdcall GLee_Lazy_glColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)  {if (GLeeInit()) glColorSubTableEXT(target, start, count, format, type, data);}
  GLEEPFNGLCOLORSUBTABLEEXTPROC GLeeFuncPtr_glColorSubTableEXT=GLee_Lazy_glColorSubTableEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyColorSubTableEXT
#define GLEE_C_DEFINED_glCopyColorSubTableEXT
  void __stdcall GLee_Lazy_glCopyColorSubTableEXT(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyColorSubTableEXT(target, start, x, y, width);}
  GLEEPFNGLCOPYCOLORSUBTABLEEXTPROC GLeeFuncPtr_glCopyColorSubTableEXT=GLee_Lazy_glCopyColorSubTableEXT;
#endif
#endif

/* GL_PGI_vertex_hints */

#ifdef __GLEE_GL_PGI_vertex_hints
#endif

/* GL_PGI_misc_hints */

#ifdef __GLEE_GL_PGI_misc_hints
#ifndef GLEE_C_DEFINED_glHintPGI
#define GLEE_C_DEFINED_glHintPGI
  void __stdcall GLee_Lazy_glHintPGI(GLenum target, GLint mode)  {if (GLeeInit()) glHintPGI(target, mode);}
  GLEEPFNGLHINTPGIPROC GLeeFuncPtr_glHintPGI=GLee_Lazy_glHintPGI;
#endif
#endif

/* GL_EXT_paletted_texture */

#ifdef __GLEE_GL_EXT_paletted_texture
#ifndef GLEE_C_DEFINED_glColorTableEXT
#define GLEE_C_DEFINED_glColorTableEXT
  void __stdcall GLee_Lazy_glColorTableEXT(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)  {if (GLeeInit()) glColorTableEXT(target, internalFormat, width, format, type, table);}
  GLEEPFNGLCOLORTABLEEXTPROC GLeeFuncPtr_glColorTableEXT=GLee_Lazy_glColorTableEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableEXT
#define GLEE_C_DEFINED_glGetColorTableEXT
  void __stdcall GLee_Lazy_glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid * data)  {if (GLeeInit()) glGetColorTableEXT(target, format, type, data);}
  GLEEPFNGLGETCOLORTABLEEXTPROC GLeeFuncPtr_glGetColorTableEXT=GLee_Lazy_glGetColorTableEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableParameterivEXT
#define GLEE_C_DEFINED_glGetColorTableParameterivEXT
  void __stdcall GLee_Lazy_glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetColorTableParameterivEXT(target, pname, params);}
  GLEEPFNGLGETCOLORTABLEPARAMETERIVEXTPROC GLeeFuncPtr_glGetColorTableParameterivEXT=GLee_Lazy_glGetColorTableParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableParameterfvEXT
#define GLEE_C_DEFINED_glGetColorTableParameterfvEXT
  void __stdcall GLee_Lazy_glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetColorTableParameterfvEXT(target, pname, params);}
  GLEEPFNGLGETCOLORTABLEPARAMETERFVEXTPROC GLeeFuncPtr_glGetColorTableParameterfvEXT=GLee_Lazy_glGetColorTableParameterfvEXT;
#endif
#endif

/* GL_EXT_clip_volume_hint */

#ifdef __GLEE_GL_EXT_clip_volume_hint
#endif

/* GL_SGIX_list_priority */

#ifdef __GLEE_GL_SGIX_list_priority
#ifndef GLEE_C_DEFINED_glGetListParameterfvSGIX
#define GLEE_C_DEFINED_glGetListParameterfvSGIX
  void __stdcall GLee_Lazy_glGetListParameterfvSGIX(GLuint list, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetListParameterfvSGIX(list, pname, params);}
  GLEEPFNGLGETLISTPARAMETERFVSGIXPROC GLeeFuncPtr_glGetListParameterfvSGIX=GLee_Lazy_glGetListParameterfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glGetListParameterivSGIX
#define GLEE_C_DEFINED_glGetListParameterivSGIX
  void __stdcall GLee_Lazy_glGetListParameterivSGIX(GLuint list, GLenum pname, GLint * params)  {if (GLeeInit()) glGetListParameterivSGIX(list, pname, params);}
  GLEEPFNGLGETLISTPARAMETERIVSGIXPROC GLeeFuncPtr_glGetListParameterivSGIX=GLee_Lazy_glGetListParameterivSGIX;
#endif
#ifndef GLEE_C_DEFINED_glListParameterfSGIX
#define GLEE_C_DEFINED_glListParameterfSGIX
  void __stdcall GLee_Lazy_glListParameterfSGIX(GLuint list, GLenum pname, GLfloat param)  {if (GLeeInit()) glListParameterfSGIX(list, pname, param);}
  GLEEPFNGLLISTPARAMETERFSGIXPROC GLeeFuncPtr_glListParameterfSGIX=GLee_Lazy_glListParameterfSGIX;
#endif
#ifndef GLEE_C_DEFINED_glListParameterfvSGIX
#define GLEE_C_DEFINED_glListParameterfvSGIX
  void __stdcall GLee_Lazy_glListParameterfvSGIX(GLuint list, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glListParameterfvSGIX(list, pname, params);}
  GLEEPFNGLLISTPARAMETERFVSGIXPROC GLeeFuncPtr_glListParameterfvSGIX=GLee_Lazy_glListParameterfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glListParameteriSGIX
#define GLEE_C_DEFINED_glListParameteriSGIX
  void __stdcall GLee_Lazy_glListParameteriSGIX(GLuint list, GLenum pname, GLint param)  {if (GLeeInit()) glListParameteriSGIX(list, pname, param);}
  GLEEPFNGLLISTPARAMETERISGIXPROC GLeeFuncPtr_glListParameteriSGIX=GLee_Lazy_glListParameteriSGIX;
#endif
#ifndef GLEE_C_DEFINED_glListParameterivSGIX
#define GLEE_C_DEFINED_glListParameterivSGIX
  void __stdcall GLee_Lazy_glListParameterivSGIX(GLuint list, GLenum pname, const GLint * params)  {if (GLeeInit()) glListParameterivSGIX(list, pname, params);}
  GLEEPFNGLLISTPARAMETERIVSGIXPROC GLeeFuncPtr_glListParameterivSGIX=GLee_Lazy_glListParameterivSGIX;
#endif
#endif

/* GL_SGIX_ir_instrument1 */

#ifdef __GLEE_GL_SGIX_ir_instrument1
#endif

/* GL_SGIX_calligraphic_fragment */

#ifdef __GLEE_GL_SGIX_calligraphic_fragment
#endif

/* GL_SGIX_texture_lod_bias */

#ifdef __GLEE_GL_SGIX_texture_lod_bias
#endif

/* GL_SGIX_shadow_ambient */

#ifdef __GLEE_GL_SGIX_shadow_ambient
#endif

/* GL_EXT_index_texture */

#ifdef __GLEE_GL_EXT_index_texture
#endif

/* GL_EXT_index_material */

#ifdef __GLEE_GL_EXT_index_material
#ifndef GLEE_C_DEFINED_glIndexMaterialEXT
#define GLEE_C_DEFINED_glIndexMaterialEXT
  void __stdcall GLee_Lazy_glIndexMaterialEXT(GLenum face, GLenum mode)  {if (GLeeInit()) glIndexMaterialEXT(face, mode);}
  GLEEPFNGLINDEXMATERIALEXTPROC GLeeFuncPtr_glIndexMaterialEXT=GLee_Lazy_glIndexMaterialEXT;
#endif
#endif

/* GL_EXT_index_func */

#ifdef __GLEE_GL_EXT_index_func
#ifndef GLEE_C_DEFINED_glIndexFuncEXT
#define GLEE_C_DEFINED_glIndexFuncEXT
  void __stdcall GLee_Lazy_glIndexFuncEXT(GLenum func, GLclampf ref)  {if (GLeeInit()) glIndexFuncEXT(func, ref);}
  GLEEPFNGLINDEXFUNCEXTPROC GLeeFuncPtr_glIndexFuncEXT=GLee_Lazy_glIndexFuncEXT;
#endif
#endif

/* GL_EXT_index_array_formats */

#ifdef __GLEE_GL_EXT_index_array_formats
#endif

/* GL_EXT_compiled_vertex_array */

#ifdef __GLEE_GL_EXT_compiled_vertex_array
#ifndef GLEE_C_DEFINED_glLockArraysEXT
#define GLEE_C_DEFINED_glLockArraysEXT
  void __stdcall GLee_Lazy_glLockArraysEXT(GLint first, GLsizei count)  {if (GLeeInit()) glLockArraysEXT(first, count);}
  GLEEPFNGLLOCKARRAYSEXTPROC GLeeFuncPtr_glLockArraysEXT=GLee_Lazy_glLockArraysEXT;
#endif
#ifndef GLEE_C_DEFINED_glUnlockArraysEXT
#define GLEE_C_DEFINED_glUnlockArraysEXT
  void __stdcall GLee_Lazy_glUnlockArraysEXT(void)  {if (GLeeInit()) glUnlockArraysEXT();}
  GLEEPFNGLUNLOCKARRAYSEXTPROC GLeeFuncPtr_glUnlockArraysEXT=GLee_Lazy_glUnlockArraysEXT;
#endif
#endif

/* GL_EXT_cull_vertex */

#ifdef __GLEE_GL_EXT_cull_vertex
#ifndef GLEE_C_DEFINED_glCullParameterdvEXT
#define GLEE_C_DEFINED_glCullParameterdvEXT
  void __stdcall GLee_Lazy_glCullParameterdvEXT(GLenum pname, GLdouble * params)  {if (GLeeInit()) glCullParameterdvEXT(pname, params);}
  GLEEPFNGLCULLPARAMETERDVEXTPROC GLeeFuncPtr_glCullParameterdvEXT=GLee_Lazy_glCullParameterdvEXT;
#endif
#ifndef GLEE_C_DEFINED_glCullParameterfvEXT
#define GLEE_C_DEFINED_glCullParameterfvEXT
  void __stdcall GLee_Lazy_glCullParameterfvEXT(GLenum pname, GLfloat * params)  {if (GLeeInit()) glCullParameterfvEXT(pname, params);}
  GLEEPFNGLCULLPARAMETERFVEXTPROC GLeeFuncPtr_glCullParameterfvEXT=GLee_Lazy_glCullParameterfvEXT;
#endif
#endif

/* GL_SGIX_ycrcb */

#ifdef __GLEE_GL_SGIX_ycrcb
#endif

/* GL_SGIX_fragment_lighting */

#ifdef __GLEE_GL_SGIX_fragment_lighting
#ifndef GLEE_C_DEFINED_glFragmentColorMaterialSGIX
#define GLEE_C_DEFINED_glFragmentColorMaterialSGIX
  void __stdcall GLee_Lazy_glFragmentColorMaterialSGIX(GLenum face, GLenum mode)  {if (GLeeInit()) glFragmentColorMaterialSGIX(face, mode);}
  GLEEPFNGLFRAGMENTCOLORMATERIALSGIXPROC GLeeFuncPtr_glFragmentColorMaterialSGIX=GLee_Lazy_glFragmentColorMaterialSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightfSGIX
#define GLEE_C_DEFINED_glFragmentLightfSGIX
  void __stdcall GLee_Lazy_glFragmentLightfSGIX(GLenum light, GLenum pname, GLfloat param)  {if (GLeeInit()) glFragmentLightfSGIX(light, pname, param);}
  GLEEPFNGLFRAGMENTLIGHTFSGIXPROC GLeeFuncPtr_glFragmentLightfSGIX=GLee_Lazy_glFragmentLightfSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightfvSGIX
#define GLEE_C_DEFINED_glFragmentLightfvSGIX
  void __stdcall GLee_Lazy_glFragmentLightfvSGIX(GLenum light, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glFragmentLightfvSGIX(light, pname, params);}
  GLEEPFNGLFRAGMENTLIGHTFVSGIXPROC GLeeFuncPtr_glFragmentLightfvSGIX=GLee_Lazy_glFragmentLightfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightiSGIX
#define GLEE_C_DEFINED_glFragmentLightiSGIX
  void __stdcall GLee_Lazy_glFragmentLightiSGIX(GLenum light, GLenum pname, GLint param)  {if (GLeeInit()) glFragmentLightiSGIX(light, pname, param);}
  GLEEPFNGLFRAGMENTLIGHTISGIXPROC GLeeFuncPtr_glFragmentLightiSGIX=GLee_Lazy_glFragmentLightiSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightivSGIX
#define GLEE_C_DEFINED_glFragmentLightivSGIX
  void __stdcall GLee_Lazy_glFragmentLightivSGIX(GLenum light, GLenum pname, const GLint * params)  {if (GLeeInit()) glFragmentLightivSGIX(light, pname, params);}
  GLEEPFNGLFRAGMENTLIGHTIVSGIXPROC GLeeFuncPtr_glFragmentLightivSGIX=GLee_Lazy_glFragmentLightivSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightModelfSGIX
#define GLEE_C_DEFINED_glFragmentLightModelfSGIX
  void __stdcall GLee_Lazy_glFragmentLightModelfSGIX(GLenum pname, GLfloat param)  {if (GLeeInit()) glFragmentLightModelfSGIX(pname, param);}
  GLEEPFNGLFRAGMENTLIGHTMODELFSGIXPROC GLeeFuncPtr_glFragmentLightModelfSGIX=GLee_Lazy_glFragmentLightModelfSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightModelfvSGIX
#define GLEE_C_DEFINED_glFragmentLightModelfvSGIX
  void __stdcall GLee_Lazy_glFragmentLightModelfvSGIX(GLenum pname, const GLfloat * params)  {if (GLeeInit()) glFragmentLightModelfvSGIX(pname, params);}
  GLEEPFNGLFRAGMENTLIGHTMODELFVSGIXPROC GLeeFuncPtr_glFragmentLightModelfvSGIX=GLee_Lazy_glFragmentLightModelfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightModeliSGIX
#define GLEE_C_DEFINED_glFragmentLightModeliSGIX
  void __stdcall GLee_Lazy_glFragmentLightModeliSGIX(GLenum pname, GLint param)  {if (GLeeInit()) glFragmentLightModeliSGIX(pname, param);}
  GLEEPFNGLFRAGMENTLIGHTMODELISGIXPROC GLeeFuncPtr_glFragmentLightModeliSGIX=GLee_Lazy_glFragmentLightModeliSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightModelivSGIX
#define GLEE_C_DEFINED_glFragmentLightModelivSGIX
  void __stdcall GLee_Lazy_glFragmentLightModelivSGIX(GLenum pname, const GLint * params)  {if (GLeeInit()) glFragmentLightModelivSGIX(pname, params);}
  GLEEPFNGLFRAGMENTLIGHTMODELIVSGIXPROC GLeeFuncPtr_glFragmentLightModelivSGIX=GLee_Lazy_glFragmentLightModelivSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentMaterialfSGIX
#define GLEE_C_DEFINED_glFragmentMaterialfSGIX
  void __stdcall GLee_Lazy_glFragmentMaterialfSGIX(GLenum face, GLenum pname, GLfloat param)  {if (GLeeInit()) glFragmentMaterialfSGIX(face, pname, param);}
  GLEEPFNGLFRAGMENTMATERIALFSGIXPROC GLeeFuncPtr_glFragmentMaterialfSGIX=GLee_Lazy_glFragmentMaterialfSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentMaterialfvSGIX
#define GLEE_C_DEFINED_glFragmentMaterialfvSGIX
  void __stdcall GLee_Lazy_glFragmentMaterialfvSGIX(GLenum face, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glFragmentMaterialfvSGIX(face, pname, params);}
  GLEEPFNGLFRAGMENTMATERIALFVSGIXPROC GLeeFuncPtr_glFragmentMaterialfvSGIX=GLee_Lazy_glFragmentMaterialfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentMaterialiSGIX
#define GLEE_C_DEFINED_glFragmentMaterialiSGIX
  void __stdcall GLee_Lazy_glFragmentMaterialiSGIX(GLenum face, GLenum pname, GLint param)  {if (GLeeInit()) glFragmentMaterialiSGIX(face, pname, param);}
  GLEEPFNGLFRAGMENTMATERIALISGIXPROC GLeeFuncPtr_glFragmentMaterialiSGIX=GLee_Lazy_glFragmentMaterialiSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentMaterialivSGIX
#define GLEE_C_DEFINED_glFragmentMaterialivSGIX
  void __stdcall GLee_Lazy_glFragmentMaterialivSGIX(GLenum face, GLenum pname, const GLint * params)  {if (GLeeInit()) glFragmentMaterialivSGIX(face, pname, params);}
  GLEEPFNGLFRAGMENTMATERIALIVSGIXPROC GLeeFuncPtr_glFragmentMaterialivSGIX=GLee_Lazy_glFragmentMaterialivSGIX;
#endif
#ifndef GLEE_C_DEFINED_glGetFragmentLightfvSGIX
#define GLEE_C_DEFINED_glGetFragmentLightfvSGIX
  void __stdcall GLee_Lazy_glGetFragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetFragmentLightfvSGIX(light, pname, params);}
  GLEEPFNGLGETFRAGMENTLIGHTFVSGIXPROC GLeeFuncPtr_glGetFragmentLightfvSGIX=GLee_Lazy_glGetFragmentLightfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glGetFragmentLightivSGIX
#define GLEE_C_DEFINED_glGetFragmentLightivSGIX
  void __stdcall GLee_Lazy_glGetFragmentLightivSGIX(GLenum light, GLenum pname, GLint * params)  {if (GLeeInit()) glGetFragmentLightivSGIX(light, pname, params);}
  GLEEPFNGLGETFRAGMENTLIGHTIVSGIXPROC GLeeFuncPtr_glGetFragmentLightivSGIX=GLee_Lazy_glGetFragmentLightivSGIX;
#endif
#ifndef GLEE_C_DEFINED_glGetFragmentMaterialfvSGIX
#define GLEE_C_DEFINED_glGetFragmentMaterialfvSGIX
  void __stdcall GLee_Lazy_glGetFragmentMaterialfvSGIX(GLenum face, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetFragmentMaterialfvSGIX(face, pname, params);}
  GLEEPFNGLGETFRAGMENTMATERIALFVSGIXPROC GLeeFuncPtr_glGetFragmentMaterialfvSGIX=GLee_Lazy_glGetFragmentMaterialfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glGetFragmentMaterialivSGIX
#define GLEE_C_DEFINED_glGetFragmentMaterialivSGIX
  void __stdcall GLee_Lazy_glGetFragmentMaterialivSGIX(GLenum face, GLenum pname, GLint * params)  {if (GLeeInit()) glGetFragmentMaterialivSGIX(face, pname, params);}
  GLEEPFNGLGETFRAGMENTMATERIALIVSGIXPROC GLeeFuncPtr_glGetFragmentMaterialivSGIX=GLee_Lazy_glGetFragmentMaterialivSGIX;
#endif
#ifndef GLEE_C_DEFINED_glLightEnviSGIX
#define GLEE_C_DEFINED_glLightEnviSGIX
  void __stdcall GLee_Lazy_glLightEnviSGIX(GLenum pname, GLint param)  {if (GLeeInit()) glLightEnviSGIX(pname, param);}
  GLEEPFNGLLIGHTENVISGIXPROC GLeeFuncPtr_glLightEnviSGIX=GLee_Lazy_glLightEnviSGIX;
#endif
#endif

/* GL_IBM_rasterpos_clip */

#ifdef __GLEE_GL_IBM_rasterpos_clip
#endif

/* GL_HP_texture_lighting */

#ifdef __GLEE_GL_HP_texture_lighting
#endif

/* GL_EXT_draw_range_elements */

#ifdef __GLEE_GL_EXT_draw_range_elements
#ifndef GLEE_C_DEFINED_glDrawRangeElementsEXT
#define GLEE_C_DEFINED_glDrawRangeElementsEXT
  void __stdcall GLee_Lazy_glDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)  {if (GLeeInit()) glDrawRangeElementsEXT(mode, start, end, count, type, indices);}
  GLEEPFNGLDRAWRANGEELEMENTSEXTPROC GLeeFuncPtr_glDrawRangeElementsEXT=GLee_Lazy_glDrawRangeElementsEXT;
#endif
#endif

/* GL_WIN_phong_shading */

#ifdef __GLEE_GL_WIN_phong_shading
#endif

/* GL_WIN_specular_fog */

#ifdef __GLEE_GL_WIN_specular_fog
#endif

/* GL_EXT_light_texture */

#ifdef __GLEE_GL_EXT_light_texture
#ifndef GLEE_C_DEFINED_glApplyTextureEXT
#define GLEE_C_DEFINED_glApplyTextureEXT
  void __stdcall GLee_Lazy_glApplyTextureEXT(GLenum mode)  {if (GLeeInit()) glApplyTextureEXT(mode);}
  GLEEPFNGLAPPLYTEXTUREEXTPROC GLeeFuncPtr_glApplyTextureEXT=GLee_Lazy_glApplyTextureEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureLightEXT
#define GLEE_C_DEFINED_glTextureLightEXT
  void __stdcall GLee_Lazy_glTextureLightEXT(GLenum pname)  {if (GLeeInit()) glTextureLightEXT(pname);}
  GLEEPFNGLTEXTURELIGHTEXTPROC GLeeFuncPtr_glTextureLightEXT=GLee_Lazy_glTextureLightEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureMaterialEXT
#define GLEE_C_DEFINED_glTextureMaterialEXT
  void __stdcall GLee_Lazy_glTextureMaterialEXT(GLenum face, GLenum mode)  {if (GLeeInit()) glTextureMaterialEXT(face, mode);}
  GLEEPFNGLTEXTUREMATERIALEXTPROC GLeeFuncPtr_glTextureMaterialEXT=GLee_Lazy_glTextureMaterialEXT;
#endif
#endif

/* GL_SGIX_blend_alpha_minmax */

#ifdef __GLEE_GL_SGIX_blend_alpha_minmax
#endif

/* GL_SGIX_impact_pixel_texture */

#ifdef __GLEE_GL_SGIX_impact_pixel_texture
#endif

/* GL_EXT_bgra */

#ifdef __GLEE_GL_EXT_bgra
#endif

/* GL_SGIX_async */

#ifdef __GLEE_GL_SGIX_async
#ifndef GLEE_C_DEFINED_glAsyncMarkerSGIX
#define GLEE_C_DEFINED_glAsyncMarkerSGIX
  void __stdcall GLee_Lazy_glAsyncMarkerSGIX(GLuint marker)  {if (GLeeInit()) glAsyncMarkerSGIX(marker);}
  GLEEPFNGLASYNCMARKERSGIXPROC GLeeFuncPtr_glAsyncMarkerSGIX=GLee_Lazy_glAsyncMarkerSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFinishAsyncSGIX
#define GLEE_C_DEFINED_glFinishAsyncSGIX
  GLint __stdcall GLee_Lazy_glFinishAsyncSGIX(GLuint * markerp)  {if (GLeeInit()) return glFinishAsyncSGIX(markerp); return (GLint)0;}
  GLEEPFNGLFINISHASYNCSGIXPROC GLeeFuncPtr_glFinishAsyncSGIX=GLee_Lazy_glFinishAsyncSGIX;
#endif
#ifndef GLEE_C_DEFINED_glPollAsyncSGIX
#define GLEE_C_DEFINED_glPollAsyncSGIX
  GLint __stdcall GLee_Lazy_glPollAsyncSGIX(GLuint * markerp)  {if (GLeeInit()) return glPollAsyncSGIX(markerp); return (GLint)0;}
  GLEEPFNGLPOLLASYNCSGIXPROC GLeeFuncPtr_glPollAsyncSGIX=GLee_Lazy_glPollAsyncSGIX;
#endif
#ifndef GLEE_C_DEFINED_glGenAsyncMarkersSGIX
#define GLEE_C_DEFINED_glGenAsyncMarkersSGIX
  GLuint __stdcall GLee_Lazy_glGenAsyncMarkersSGIX(GLsizei range)  {if (GLeeInit()) return glGenAsyncMarkersSGIX(range); return (GLuint)0;}
  GLEEPFNGLGENASYNCMARKERSSGIXPROC GLeeFuncPtr_glGenAsyncMarkersSGIX=GLee_Lazy_glGenAsyncMarkersSGIX;
#endif
#ifndef GLEE_C_DEFINED_glDeleteAsyncMarkersSGIX
#define GLEE_C_DEFINED_glDeleteAsyncMarkersSGIX
  void __stdcall GLee_Lazy_glDeleteAsyncMarkersSGIX(GLuint marker, GLsizei range)  {if (GLeeInit()) glDeleteAsyncMarkersSGIX(marker, range);}
  GLEEPFNGLDELETEASYNCMARKERSSGIXPROC GLeeFuncPtr_glDeleteAsyncMarkersSGIX=GLee_Lazy_glDeleteAsyncMarkersSGIX;
#endif
#ifndef GLEE_C_DEFINED_glIsAsyncMarkerSGIX
#define GLEE_C_DEFINED_glIsAsyncMarkerSGIX
  GLboolean __stdcall GLee_Lazy_glIsAsyncMarkerSGIX(GLuint marker)  {if (GLeeInit()) return glIsAsyncMarkerSGIX(marker); return (GLboolean)0;}
  GLEEPFNGLISASYNCMARKERSGIXPROC GLeeFuncPtr_glIsAsyncMarkerSGIX=GLee_Lazy_glIsAsyncMarkerSGIX;
#endif
#endif

/* GL_SGIX_async_pixel */

#ifdef __GLEE_GL_SGIX_async_pixel
#endif

/* GL_SGIX_async_histogram */

#ifdef __GLEE_GL_SGIX_async_histogram
#endif

/* GL_INTEL_texture_scissor */

#ifdef __GLEE_GL_INTEL_texture_scissor
#endif

/* GL_INTEL_parallel_arrays */

#ifdef __GLEE_GL_INTEL_parallel_arrays
#ifndef GLEE_C_DEFINED_glVertexPointervINTEL
#define GLEE_C_DEFINED_glVertexPointervINTEL
  void __stdcall GLee_Lazy_glVertexPointervINTEL(GLint size, GLenum type, const GLvoid* * pointer)  {if (GLeeInit()) glVertexPointervINTEL(size, type, pointer);}
  GLEEPFNGLVERTEXPOINTERVINTELPROC GLeeFuncPtr_glVertexPointervINTEL=GLee_Lazy_glVertexPointervINTEL;
#endif
#ifndef GLEE_C_DEFINED_glNormalPointervINTEL
#define GLEE_C_DEFINED_glNormalPointervINTEL
  void __stdcall GLee_Lazy_glNormalPointervINTEL(GLenum type, const GLvoid* * pointer)  {if (GLeeInit()) glNormalPointervINTEL(type, pointer);}
  GLEEPFNGLNORMALPOINTERVINTELPROC GLeeFuncPtr_glNormalPointervINTEL=GLee_Lazy_glNormalPointervINTEL;
#endif
#ifndef GLEE_C_DEFINED_glColorPointervINTEL
#define GLEE_C_DEFINED_glColorPointervINTEL
  void __stdcall GLee_Lazy_glColorPointervINTEL(GLint size, GLenum type, const GLvoid* * pointer)  {if (GLeeInit()) glColorPointervINTEL(size, type, pointer);}
  GLEEPFNGLCOLORPOINTERVINTELPROC GLeeFuncPtr_glColorPointervINTEL=GLee_Lazy_glColorPointervINTEL;
#endif
#ifndef GLEE_C_DEFINED_glTexCoordPointervINTEL
#define GLEE_C_DEFINED_glTexCoordPointervINTEL
  void __stdcall GLee_Lazy_glTexCoordPointervINTEL(GLint size, GLenum type, const GLvoid* * pointer)  {if (GLeeInit()) glTexCoordPointervINTEL(size, type, pointer);}
  GLEEPFNGLTEXCOORDPOINTERVINTELPROC GLeeFuncPtr_glTexCoordPointervINTEL=GLee_Lazy_glTexCoordPointervINTEL;
#endif
#endif

/* GL_HP_occlusion_test */

#ifdef __GLEE_GL_HP_occlusion_test
#endif

/* GL_EXT_pixel_transform */

#ifdef __GLEE_GL_EXT_pixel_transform
#ifndef GLEE_C_DEFINED_glPixelTransformParameteriEXT
#define GLEE_C_DEFINED_glPixelTransformParameteriEXT
  void __stdcall GLee_Lazy_glPixelTransformParameteriEXT(GLenum target, GLenum pname, GLint param)  {if (GLeeInit()) glPixelTransformParameteriEXT(target, pname, param);}
  GLEEPFNGLPIXELTRANSFORMPARAMETERIEXTPROC GLeeFuncPtr_glPixelTransformParameteriEXT=GLee_Lazy_glPixelTransformParameteriEXT;
#endif
#ifndef GLEE_C_DEFINED_glPixelTransformParameterfEXT
#define GLEE_C_DEFINED_glPixelTransformParameterfEXT
  void __stdcall GLee_Lazy_glPixelTransformParameterfEXT(GLenum target, GLenum pname, GLfloat param)  {if (GLeeInit()) glPixelTransformParameterfEXT(target, pname, param);}
  GLEEPFNGLPIXELTRANSFORMPARAMETERFEXTPROC GLeeFuncPtr_glPixelTransformParameterfEXT=GLee_Lazy_glPixelTransformParameterfEXT;
#endif
#ifndef GLEE_C_DEFINED_glPixelTransformParameterivEXT
#define GLEE_C_DEFINED_glPixelTransformParameterivEXT
  void __stdcall GLee_Lazy_glPixelTransformParameterivEXT(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glPixelTransformParameterivEXT(target, pname, params);}
  GLEEPFNGLPIXELTRANSFORMPARAMETERIVEXTPROC GLeeFuncPtr_glPixelTransformParameterivEXT=GLee_Lazy_glPixelTransformParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glPixelTransformParameterfvEXT
#define GLEE_C_DEFINED_glPixelTransformParameterfvEXT
  void __stdcall GLee_Lazy_glPixelTransformParameterfvEXT(GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glPixelTransformParameterfvEXT(target, pname, params);}
  GLEEPFNGLPIXELTRANSFORMPARAMETERFVEXTPROC GLeeFuncPtr_glPixelTransformParameterfvEXT=GLee_Lazy_glPixelTransformParameterfvEXT;
#endif
#endif

/* GL_EXT_pixel_transform_color_table */

#ifdef __GLEE_GL_EXT_pixel_transform_color_table
#endif

/* GL_EXT_shared_texture_palette */

#ifdef __GLEE_GL_EXT_shared_texture_palette
#endif

/* GL_EXT_separate_specular_color */

#ifdef __GLEE_GL_EXT_separate_specular_color
#endif

/* GL_EXT_secondary_color */

#ifdef __GLEE_GL_EXT_secondary_color
#ifndef GLEE_C_DEFINED_glSecondaryColor3bEXT
#define GLEE_C_DEFINED_glSecondaryColor3bEXT
  void __stdcall GLee_Lazy_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)  {if (GLeeInit()) glSecondaryColor3bEXT(red, green, blue);}
  GLEEPFNGLSECONDARYCOLOR3BEXTPROC GLeeFuncPtr_glSecondaryColor3bEXT=GLee_Lazy_glSecondaryColor3bEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3bvEXT
#define GLEE_C_DEFINED_glSecondaryColor3bvEXT
  void __stdcall GLee_Lazy_glSecondaryColor3bvEXT(const GLbyte * v)  {if (GLeeInit()) glSecondaryColor3bvEXT(v);}
  GLEEPFNGLSECONDARYCOLOR3BVEXTPROC GLeeFuncPtr_glSecondaryColor3bvEXT=GLee_Lazy_glSecondaryColor3bvEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3dEXT
#define GLEE_C_DEFINED_glSecondaryColor3dEXT
  void __stdcall GLee_Lazy_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)  {if (GLeeInit()) glSecondaryColor3dEXT(red, green, blue);}
  GLEEPFNGLSECONDARYCOLOR3DEXTPROC GLeeFuncPtr_glSecondaryColor3dEXT=GLee_Lazy_glSecondaryColor3dEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3dvEXT
#define GLEE_C_DEFINED_glSecondaryColor3dvEXT
  void __stdcall GLee_Lazy_glSecondaryColor3dvEXT(const GLdouble * v)  {if (GLeeInit()) glSecondaryColor3dvEXT(v);}
  GLEEPFNGLSECONDARYCOLOR3DVEXTPROC GLeeFuncPtr_glSecondaryColor3dvEXT=GLee_Lazy_glSecondaryColor3dvEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3fEXT
#define GLEE_C_DEFINED_glSecondaryColor3fEXT
  void __stdcall GLee_Lazy_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)  {if (GLeeInit()) glSecondaryColor3fEXT(red, green, blue);}
  GLEEPFNGLSECONDARYCOLOR3FEXTPROC GLeeFuncPtr_glSecondaryColor3fEXT=GLee_Lazy_glSecondaryColor3fEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3fvEXT
#define GLEE_C_DEFINED_glSecondaryColor3fvEXT
  void __stdcall GLee_Lazy_glSecondaryColor3fvEXT(const GLfloat * v)  {if (GLeeInit()) glSecondaryColor3fvEXT(v);}
  GLEEPFNGLSECONDARYCOLOR3FVEXTPROC GLeeFuncPtr_glSecondaryColor3fvEXT=GLee_Lazy_glSecondaryColor3fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3iEXT
#define GLEE_C_DEFINED_glSecondaryColor3iEXT
  void __stdcall GLee_Lazy_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)  {if (GLeeInit()) glSecondaryColor3iEXT(<