Newer
Older
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010
4011
4012
4013
4014
4015
4016
4017
4018
4019
4020
4021
4022
4023
4024
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037
4038
4039
4040
4041
4042
4043
4044
4045
4046
4047
4048
4049
4050
4051
4052
4053
4054
4055
4056
4057
4058
4059
4060
4061
4062
4063
4064
4065
4066
4067
4068
4069
4070
4071
4072
4073
4074
4075
4076
4077
4078
4079
4080
4081
4082
4083
4084
4085
4086
4087
4088
4089
4090
4091
4092
4093
4094
4095
4096
4097
4098
4099
4100
4101
4102
4103
4104
4105
4106
4107
4108
4109
4110
4111
4112
4113
4114
4115
4116
4117
4118
4119
4120
4121
4122
4123
4124
4125
4126
4127
4128
4129
4130
4131
4132
4133
4134
4135
4136
4137
4138
4139
4140
4141
4142
4143
4144
4145
4146
4147
4148
4149
4150
4151
4152
4153
4154
4155
4156
4157
4158
4159
4160
4161
4162
4163
4164
4165
4166
4167
4168
4169
4170
4171
4172
4173
4174
4175
4176
4177
4178
4179
4180
4181
4182
4183
4184
4185
4186
4187
4188
4189
4190
4191
4192
4193
4194
4195
4196
4197
4198
4199
4200
4201
4202
4203
4204
4205
4206
4207
4208
4209
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222
4223
4224
4225
4226
4227
4228
4229
4230
4231
4232
4233
4234
4235
4236
4237
4238
4239
4240
4241
4242
4243
4244
4245
4246
4247
4248
4249
4250
4251
4252
4253
4254
4255
4256
4257
4258
4259
4260
4261
4262
4263
4264
4265
4266
4267
4268
4269
4270
4271
4272
4273
4274
4275
4276
4277
4278
4279
4280
4281
4282
4283
4284
4285
4286
4287
4288
4289
4290
4291
4292
4293
4294
4295
4296
4297
4298
4299
4300
4301
4302
4303
4304
4305
4306
4307
4308
4309
4310
4311
4312
4313
4314
4315
4316
4317
4318
4319
4320
4321
4322
4323
4324
4325
4326
4327
4328
4329
4330
4331
4332
4333
4334
4335
4336
4337
4338
4339
4340
4341
4342
4343
4344
4345
4346
4347
4348
4349
4350
4351
4352
4353
4354
4355
4356
4357
4358
4359
4360
4361
4362
4363
4364
4365
4366
4367
4368
4369
4370
4371
4372
4373
4374
4375
4376
4377
4378
4379
4380
4381
4382
4383
4384
4385
4386
4387
4388
4389
4390
4391
4392
4393
4394
4395
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
4406
4407
4408
4409
4410
4411
4412
4413
4414
4415
4416
4417
4418
4419
4420
4421
4422
4423
4424
4425
4426
4427
4428
4429
4430
4431
4432
4433
4434
4435
4436
4437
4438
4439
4440
4441
4442
4443
4444
4445
4446
4447
4448
4449
4450
4451
4452
4453
4454
4455
4456
4457
4458
4459
4460
4461
4462
4463
4464
4465
4466
4467
4468
4469
4470
4471
4472
4473
4474
4475
4476
4477
4478
4479
4480
4481
4482
4483
4484
4485
4486
4487
4488
4489
4490
4491
4492
4493
4494
4495
4496
4497
4498
4499
4500
4501
4502
4503
4504
4505
4506
4507
4508
4509
4510
4511
4512
4513
4514
4515
4516
4517
4518
4519
4520
4521
4522
4523
4524
4525
4526
4527
4528
4529
4530
4531
4532
4533
4534
4535
4536
4537
4538
4539
4540
4541
4542
4543
4544
4545
4546
4547
4548
4549
4550
4551
4552
4553
4554
4555
4556
4557
4558
4559
4560
4561
4562
4563
4564
4565
4566
4567
4568
4569
4570
4571
4572
4573
4574
4575
4576
4577
4578
4579
4580
4581
4582
4583
4584
4585
4586
4587
4588
4589
4590
4591
4592
4593
4594
4595
4596
4597
4598
4599
4600
4601
4602
4603
4604
4605
4606
4607
4608
4609
4610
4611
4612
4613
4614
4615
4616
4617
4618
4619
4620
4621
4622
4623
4624
4625
4626
4627
4628
4629
4630
4631
4632
4633
4634
4635
4636
4637
4638
4639
4640
4641
4642
4643
4644
4645
4646
4647
4648
4649
4650
4651
4652
4653
4654
4655
4656
4657
4658
4659
4660
4661
4662
4663
4664
4665
4666
4667
4668
4669
4670
4671
4672
4673
4674
4675
4676
4677
4678
4679
4680
4681
4682
4683
4684
4685
4686
4687
4688
4689
4690
4691
4692
4693
4694
4695
4696
4697
4698
4699
4700
4701
4702
4703
4704
4705
4706
4707
4708
4709
4710
4711
4712
4713
4714
4715
4716
4717
4718
4719
4720
4721
4722
4723
4724
4725
4726
4727
4728
4729
4730
4731
4732
4733
4734
4735
4736
4737
4738
4739
4740
4741
4742
4743
4744
4745
4746
4747
4748
4749
4750
4751
4752
4753
4754
4755
4756
4757
4758
4759
4760
4761
4762
4763
4764
4765
4766
4767
4768
4769
4770
4771
4772
4773
4774
4775
4776
4777
4778
4779
4780
4781
4782
4783
4784
4785
4786
4787
4788
4789
4790
4791
4792
4793
4794
4795
4796
4797
4798
4799
4800
4801
4802
4803
4804
4805
4806
4807
4808
4809
4810
4811
4812
4813
4814
4815
4816
4817
4818
4819
4820
4821
4822
4823
4824
4825
4826
4827
4828
4829
4830
4831
4832
4833
4834
4835
4836
4837
4838
4839
4840
4841
4842
4843
4844
4845
4846
4847
4848
4849
4850
4851
4852
4853
4854
4855
4856
4857
4858
4859
4860
4861
4862
4863
4864
4865
4866
4867
4868
4869
4870
4871
4872
4873
4874
4875
4876
4877
4878
4879
4880
4881
4882
4883
4884
4885
4886
4887
4888
4889
4890
4891
4892
4893
4894
4895
4896
4897
4898
4899
4900
4901
4902
4903
4904
4905
4906
4907
4908
4909
4910
4911
4912
4913
4914
4915
4916
4917
4918
4919
4920
4921
4922
4923
4924
4925
4926
4927
4928
4929
4930
4931
4932
4933
4934
4935
4936
4937
4938
4939
4940
4941
4942
4943
4944
4945
4946
4947
4948
4949
4950
4951
4952
4953
4954
4955
4956
4957
4958
4959
4960
4961
4962
4963
4964
4965
4966
4967
4968
4969
4970
4971
4972
4973
4974
4975
4976
4977
4978
4979
4980
4981
4982
4983
4984
4985
4986
4987
4988
4989
4990
4991
4992
4993
4994
4995
4996
4997
4998
4999
5000
PFNGLDRAWRANGEELEMENTARRAYATIPROC pglDrawRangeElementArrayATI=_Lazy_glDrawRangeElementArrayATI;
#endif
/* GL_SUN_mesh_array */
#ifdef __GLEE_GL_SUN_mesh_array
void __stdcall _Lazy_glDrawMeshArraysSUN(GLenum mode, GLint first, GLsizei count, GLsizei width) {if (GLeeInit()) glDrawMeshArraysSUN(mode, first, count, width);}
PFNGLDRAWMESHARRAYSSUNPROC pglDrawMeshArraysSUN=_Lazy_glDrawMeshArraysSUN;
#endif
/* GL_SUN_slice_accum */
#ifdef __GLEE_GL_SUN_slice_accum
#endif
/* GL_NV_multisample_filter_hint */
#ifdef __GLEE_GL_NV_multisample_filter_hint
#endif
/* GL_NV_depth_clamp */
#ifdef __GLEE_GL_NV_depth_clamp
#endif
/* GL_NV_occlusion_query */
#ifdef __GLEE_GL_NV_occlusion_query
void __stdcall _Lazy_glGenOcclusionQueriesNV(GLsizei n, GLuint * ids) {if (GLeeInit()) glGenOcclusionQueriesNV(n, ids);}
void __stdcall _Lazy_glDeleteOcclusionQueriesNV(GLsizei n, const GLuint * ids) {if (GLeeInit()) glDeleteOcclusionQueriesNV(n, ids);}
GLboolean __stdcall _Lazy_glIsOcclusionQueryNV(GLuint id) {if (GLeeInit()) return glIsOcclusionQueryNV(id); return (GLboolean)0;}
void __stdcall _Lazy_glBeginOcclusionQueryNV(GLuint id) {if (GLeeInit()) glBeginOcclusionQueryNV(id);}
void __stdcall _Lazy_glEndOcclusionQueryNV(void) {if (GLeeInit()) glEndOcclusionQueryNV();}
void __stdcall _Lazy_glGetOcclusionQueryivNV(GLuint id, GLenum pname, GLint * params) {if (GLeeInit()) glGetOcclusionQueryivNV(id, pname, params);}
void __stdcall _Lazy_glGetOcclusionQueryuivNV(GLuint id, GLenum pname, GLuint * params) {if (GLeeInit()) glGetOcclusionQueryuivNV(id, pname, params);}
PFNGLGENOCCLUSIONQUERIESNVPROC pglGenOcclusionQueriesNV=_Lazy_glGenOcclusionQueriesNV;
PFNGLDELETEOCCLUSIONQUERIESNVPROC pglDeleteOcclusionQueriesNV=_Lazy_glDeleteOcclusionQueriesNV;
PFNGLISOCCLUSIONQUERYNVPROC pglIsOcclusionQueryNV=_Lazy_glIsOcclusionQueryNV;
PFNGLBEGINOCCLUSIONQUERYNVPROC pglBeginOcclusionQueryNV=_Lazy_glBeginOcclusionQueryNV;
PFNGLENDOCCLUSIONQUERYNVPROC pglEndOcclusionQueryNV=_Lazy_glEndOcclusionQueryNV;
PFNGLGETOCCLUSIONQUERYIVNVPROC pglGetOcclusionQueryivNV=_Lazy_glGetOcclusionQueryivNV;
PFNGLGETOCCLUSIONQUERYUIVNVPROC pglGetOcclusionQueryuivNV=_Lazy_glGetOcclusionQueryuivNV;
#endif
/* GL_NV_point_sprite */
#ifdef __GLEE_GL_NV_point_sprite
void __stdcall _Lazy_glPointParameteriNV(GLenum pname, GLint param) {if (GLeeInit()) glPointParameteriNV(pname, param);}
void __stdcall _Lazy_glPointParameterivNV(GLenum pname, const GLint * params) {if (GLeeInit()) glPointParameterivNV(pname, params);}
PFNGLPOINTPARAMETERINVPROC pglPointParameteriNV=_Lazy_glPointParameteriNV;
PFNGLPOINTPARAMETERIVNVPROC pglPointParameterivNV=_Lazy_glPointParameterivNV;
#endif
/* GL_NV_texture_shader3 */
#ifdef __GLEE_GL_NV_texture_shader3
#endif
/* GL_NV_vertex_program1_1 */
#ifdef __GLEE_GL_NV_vertex_program1_1
#endif
/* GL_EXT_shadow_funcs */
#ifdef __GLEE_GL_EXT_shadow_funcs
#endif
/* GL_EXT_stencil_two_side */
#ifdef __GLEE_GL_EXT_stencil_two_side
void __stdcall _Lazy_glActiveStencilFaceEXT(GLenum face) {if (GLeeInit()) glActiveStencilFaceEXT(face);}
PFNGLACTIVESTENCILFACEEXTPROC pglActiveStencilFaceEXT=_Lazy_glActiveStencilFaceEXT;
#endif
/* GL_ATI_text_fragment_shader */
#ifdef __GLEE_GL_ATI_text_fragment_shader
#endif
/* GL_APPLE_client_storage */
#ifdef __GLEE_GL_APPLE_client_storage
#endif
/* GL_APPLE_element_array */
#ifdef __GLEE_GL_APPLE_element_array
void __stdcall _Lazy_glElementPointerAPPLE(GLenum type, const GLvoid * pointer) {if (GLeeInit()) glElementPointerAPPLE(type, pointer);}
void __stdcall _Lazy_glDrawElementArrayAPPLE(GLenum mode, GLint first, GLsizei count) {if (GLeeInit()) glDrawElementArrayAPPLE(mode, first, count);}
void __stdcall _Lazy_glDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count) {if (GLeeInit()) glDrawRangeElementArrayAPPLE(mode, start, end, first, count);}
void __stdcall _Lazy_glMultiDrawElementArrayAPPLE(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount) {if (GLeeInit()) glMultiDrawElementArrayAPPLE(mode, first, count, primcount);}
void __stdcall _Lazy_glMultiDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, const GLint * first, const GLsizei * count, GLsizei primcount) {if (GLeeInit()) glMultiDrawRangeElementArrayAPPLE(mode, start, end, first, count, primcount);}
PFNGLELEMENTPOINTERAPPLEPROC pglElementPointerAPPLE=_Lazy_glElementPointerAPPLE;
PFNGLDRAWELEMENTARRAYAPPLEPROC pglDrawElementArrayAPPLE=_Lazy_glDrawElementArrayAPPLE;
PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC pglDrawRangeElementArrayAPPLE=_Lazy_glDrawRangeElementArrayAPPLE;
PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC pglMultiDrawElementArrayAPPLE=_Lazy_glMultiDrawElementArrayAPPLE;
PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC pglMultiDrawRangeElementArrayAPPLE=_Lazy_glMultiDrawRangeElementArrayAPPLE;
#endif
/* GL_APPLE_fence */
#ifdef __GLEE_GL_APPLE_fence
void __stdcall _Lazy_glGenFencesAPPLE(GLsizei n, GLuint * fences) {if (GLeeInit()) glGenFencesAPPLE(n, fences);}
void __stdcall _Lazy_glDeleteFencesAPPLE(GLsizei n, const GLuint * fences) {if (GLeeInit()) glDeleteFencesAPPLE(n, fences);}
void __stdcall _Lazy_glSetFenceAPPLE(GLuint fence) {if (GLeeInit()) glSetFenceAPPLE(fence);}
GLboolean __stdcall _Lazy_glIsFenceAPPLE(GLuint fence) {if (GLeeInit()) return glIsFenceAPPLE(fence); return (GLboolean)0;}
GLboolean __stdcall _Lazy_glTestFenceAPPLE(GLuint fence) {if (GLeeInit()) return glTestFenceAPPLE(fence); return (GLboolean)0;}
void __stdcall _Lazy_glFinishFenceAPPLE(GLuint fence) {if (GLeeInit()) glFinishFenceAPPLE(fence);}
GLboolean __stdcall _Lazy_glTestObjectAPPLE(GLenum object, GLuint name) {if (GLeeInit()) return glTestObjectAPPLE(object, name); return (GLboolean)0;}
void __stdcall _Lazy_glFinishObjectAPPLE(GLenum object, GLint name) {if (GLeeInit()) glFinishObjectAPPLE(object, name);}
PFNGLGENFENCESAPPLEPROC pglGenFencesAPPLE=_Lazy_glGenFencesAPPLE;
PFNGLDELETEFENCESAPPLEPROC pglDeleteFencesAPPLE=_Lazy_glDeleteFencesAPPLE;
PFNGLSETFENCEAPPLEPROC pglSetFenceAPPLE=_Lazy_glSetFenceAPPLE;
PFNGLISFENCEAPPLEPROC pglIsFenceAPPLE=_Lazy_glIsFenceAPPLE;
PFNGLTESTFENCEAPPLEPROC pglTestFenceAPPLE=_Lazy_glTestFenceAPPLE;
PFNGLFINISHFENCEAPPLEPROC pglFinishFenceAPPLE=_Lazy_glFinishFenceAPPLE;
PFNGLTESTOBJECTAPPLEPROC pglTestObjectAPPLE=_Lazy_glTestObjectAPPLE;
PFNGLFINISHOBJECTAPPLEPROC pglFinishObjectAPPLE=_Lazy_glFinishObjectAPPLE;
#endif
/* GL_APPLE_vertex_array_object */
#ifdef __GLEE_GL_APPLE_vertex_array_object
void __stdcall _Lazy_glBindVertexArrayAPPLE(GLuint array) {if (GLeeInit()) glBindVertexArrayAPPLE(array);}
void __stdcall _Lazy_glDeleteVertexArraysAPPLE(GLsizei n, const GLuint * arrays) {if (GLeeInit()) glDeleteVertexArraysAPPLE(n, arrays);}
void __stdcall _Lazy_glGenVertexArraysAPPLE(GLsizei n, GLuint * arrays) {if (GLeeInit()) glGenVertexArraysAPPLE(n, arrays);}
GLboolean __stdcall _Lazy_glIsVertexArrayAPPLE(GLuint array) {if (GLeeInit()) return glIsVertexArrayAPPLE(array); return (GLboolean)0;}
PFNGLBINDVERTEXARRAYAPPLEPROC pglBindVertexArrayAPPLE=_Lazy_glBindVertexArrayAPPLE;
PFNGLDELETEVERTEXARRAYSAPPLEPROC pglDeleteVertexArraysAPPLE=_Lazy_glDeleteVertexArraysAPPLE;
PFNGLGENVERTEXARRAYSAPPLEPROC pglGenVertexArraysAPPLE=_Lazy_glGenVertexArraysAPPLE;
PFNGLISVERTEXARRAYAPPLEPROC pglIsVertexArrayAPPLE=_Lazy_glIsVertexArrayAPPLE;
#endif
/* GL_APPLE_vertex_array_range */
#ifdef __GLEE_GL_APPLE_vertex_array_range
void __stdcall _Lazy_glVertexArrayRangeAPPLE(GLsizei length, GLvoid * pointer) {if (GLeeInit()) glVertexArrayRangeAPPLE(length, pointer);}
void __stdcall _Lazy_glFlushVertexArrayRangeAPPLE(GLsizei length, GLvoid * pointer) {if (GLeeInit()) glFlushVertexArrayRangeAPPLE(length, pointer);}
void __stdcall _Lazy_glVertexArrayParameteriAPPLE(GLenum pname, GLint param) {if (GLeeInit()) glVertexArrayParameteriAPPLE(pname, param);}
PFNGLVERTEXARRAYRANGEAPPLEPROC pglVertexArrayRangeAPPLE=_Lazy_glVertexArrayRangeAPPLE;
PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC pglFlushVertexArrayRangeAPPLE=_Lazy_glFlushVertexArrayRangeAPPLE;
PFNGLVERTEXARRAYPARAMETERIAPPLEPROC pglVertexArrayParameteriAPPLE=_Lazy_glVertexArrayParameteriAPPLE;
#endif
/* GL_APPLE_ycbcr_422 */
#ifdef __GLEE_GL_APPLE_ycbcr_422
#endif
/* GL_S3_s3tc */
#ifdef __GLEE_GL_S3_s3tc
#endif
/* GL_ATI_draw_buffers */
#ifdef __GLEE_GL_ATI_draw_buffers
void __stdcall _Lazy_glDrawBuffersATI(GLsizei n, const GLenum * bufs) {if (GLeeInit()) glDrawBuffersATI(n, bufs);}
PFNGLDRAWBUFFERSATIPROC pglDrawBuffersATI=_Lazy_glDrawBuffersATI;
#endif
/* GL_ATI_pixel_format_float */
#ifdef __GLEE_GL_ATI_pixel_format_float
#endif
/* GL_ATI_texture_env_combine3 */
#ifdef __GLEE_GL_ATI_texture_env_combine3
#endif
/* GL_ATI_texture_float */
#ifdef __GLEE_GL_ATI_texture_float
#endif
/* GL_NV_float_buffer */
#ifdef __GLEE_GL_NV_float_buffer
#endif
/* GL_NV_fragment_program */
#ifdef __GLEE_GL_NV_fragment_program
void __stdcall _Lazy_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glProgramNamedParameter4fNV(id, len, name, x, y, z, w);}
void __stdcall _Lazy_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glProgramNamedParameter4dNV(id, len, name, x, y, z, w);}
void __stdcall _Lazy_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v) {if (GLeeInit()) glProgramNamedParameter4fvNV(id, len, name, v);}
void __stdcall _Lazy_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v) {if (GLeeInit()) glProgramNamedParameter4dvNV(id, len, name, v);}
void __stdcall _Lazy_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params) {if (GLeeInit()) glGetProgramNamedParameterfvNV(id, len, name, params);}
void __stdcall _Lazy_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params) {if (GLeeInit()) glGetProgramNamedParameterdvNV(id, len, name, params);}
PFNGLPROGRAMNAMEDPARAMETER4FNVPROC pglProgramNamedParameter4fNV=_Lazy_glProgramNamedParameter4fNV;
PFNGLPROGRAMNAMEDPARAMETER4DNVPROC pglProgramNamedParameter4dNV=_Lazy_glProgramNamedParameter4dNV;
PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC pglProgramNamedParameter4fvNV=_Lazy_glProgramNamedParameter4fvNV;
PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC pglProgramNamedParameter4dvNV=_Lazy_glProgramNamedParameter4dvNV;
PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC pglGetProgramNamedParameterfvNV=_Lazy_glGetProgramNamedParameterfvNV;
PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC pglGetProgramNamedParameterdvNV=_Lazy_glGetProgramNamedParameterdvNV;
#endif
/* GL_NV_half_float */
#ifdef __GLEE_GL_NV_half_float
void __stdcall _Lazy_glVertex2hNV(GLhalfNV x, GLhalfNV y) {if (GLeeInit()) glVertex2hNV(x, y);}
void __stdcall _Lazy_glVertex2hvNV(const GLhalfNV * v) {if (GLeeInit()) glVertex2hvNV(v);}
void __stdcall _Lazy_glVertex3hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z) {if (GLeeInit()) glVertex3hNV(x, y, z);}
void __stdcall _Lazy_glVertex3hvNV(const GLhalfNV * v) {if (GLeeInit()) glVertex3hvNV(v);}
void __stdcall _Lazy_glVertex4hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w) {if (GLeeInit()) glVertex4hNV(x, y, z, w);}
void __stdcall _Lazy_glVertex4hvNV(const GLhalfNV * v) {if (GLeeInit()) glVertex4hvNV(v);}
void __stdcall _Lazy_glNormal3hNV(GLhalfNV nx, GLhalfNV ny, GLhalfNV nz) {if (GLeeInit()) glNormal3hNV(nx, ny, nz);}
void __stdcall _Lazy_glNormal3hvNV(const GLhalfNV * v) {if (GLeeInit()) glNormal3hvNV(v);}
void __stdcall _Lazy_glColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue) {if (GLeeInit()) glColor3hNV(red, green, blue);}
void __stdcall _Lazy_glColor3hvNV(const GLhalfNV * v) {if (GLeeInit()) glColor3hvNV(v);}
void __stdcall _Lazy_glColor4hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha) {if (GLeeInit()) glColor4hNV(red, green, blue, alpha);}
void __stdcall _Lazy_glColor4hvNV(const GLhalfNV * v) {if (GLeeInit()) glColor4hvNV(v);}
void __stdcall _Lazy_glTexCoord1hNV(GLhalfNV s) {if (GLeeInit()) glTexCoord1hNV(s);}
void __stdcall _Lazy_glTexCoord1hvNV(const GLhalfNV * v) {if (GLeeInit()) glTexCoord1hvNV(v);}
void __stdcall _Lazy_glTexCoord2hNV(GLhalfNV s, GLhalfNV t) {if (GLeeInit()) glTexCoord2hNV(s, t);}
void __stdcall _Lazy_glTexCoord2hvNV(const GLhalfNV * v) {if (GLeeInit()) glTexCoord2hvNV(v);}
void __stdcall _Lazy_glTexCoord3hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r) {if (GLeeInit()) glTexCoord3hNV(s, t, r);}
void __stdcall _Lazy_glTexCoord3hvNV(const GLhalfNV * v) {if (GLeeInit()) glTexCoord3hvNV(v);}
void __stdcall _Lazy_glTexCoord4hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q) {if (GLeeInit()) glTexCoord4hNV(s, t, r, q);}
void __stdcall _Lazy_glTexCoord4hvNV(const GLhalfNV * v) {if (GLeeInit()) glTexCoord4hvNV(v);}
void __stdcall _Lazy_glMultiTexCoord1hNV(GLenum target, GLhalfNV s) {if (GLeeInit()) glMultiTexCoord1hNV(target, s);}
void __stdcall _Lazy_glMultiTexCoord1hvNV(GLenum target, const GLhalfNV * v) {if (GLeeInit()) glMultiTexCoord1hvNV(target, v);}
void __stdcall _Lazy_glMultiTexCoord2hNV(GLenum target, GLhalfNV s, GLhalfNV t) {if (GLeeInit()) glMultiTexCoord2hNV(target, s, t);}
void __stdcall _Lazy_glMultiTexCoord2hvNV(GLenum target, const GLhalfNV * v) {if (GLeeInit()) glMultiTexCoord2hvNV(target, v);}
void __stdcall _Lazy_glMultiTexCoord3hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r) {if (GLeeInit()) glMultiTexCoord3hNV(target, s, t, r);}
void __stdcall _Lazy_glMultiTexCoord3hvNV(GLenum target, const GLhalfNV * v) {if (GLeeInit()) glMultiTexCoord3hvNV(target, v);}
void __stdcall _Lazy_glMultiTexCoord4hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q) {if (GLeeInit()) glMultiTexCoord4hNV(target, s, t, r, q);}
void __stdcall _Lazy_glMultiTexCoord4hvNV(GLenum target, const GLhalfNV * v) {if (GLeeInit()) glMultiTexCoord4hvNV(target, v);}
void __stdcall _Lazy_glFogCoordhNV(GLhalfNV fog) {if (GLeeInit()) glFogCoordhNV(fog);}
void __stdcall _Lazy_glFogCoordhvNV(const GLhalfNV * fog) {if (GLeeInit()) glFogCoordhvNV(fog);}
void __stdcall _Lazy_glSecondaryColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue) {if (GLeeInit()) glSecondaryColor3hNV(red, green, blue);}
void __stdcall _Lazy_glSecondaryColor3hvNV(const GLhalfNV * v) {if (GLeeInit()) glSecondaryColor3hvNV(v);}
void __stdcall _Lazy_glVertexWeighthNV(GLhalfNV weight) {if (GLeeInit()) glVertexWeighthNV(weight);}
void __stdcall _Lazy_glVertexWeighthvNV(const GLhalfNV * weight) {if (GLeeInit()) glVertexWeighthvNV(weight);}
void __stdcall _Lazy_glVertexAttrib1hNV(GLuint index, GLhalfNV x) {if (GLeeInit()) glVertexAttrib1hNV(index, x);}
void __stdcall _Lazy_glVertexAttrib1hvNV(GLuint index, const GLhalfNV * v) {if (GLeeInit()) glVertexAttrib1hvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib2hNV(GLuint index, GLhalfNV x, GLhalfNV y) {if (GLeeInit()) glVertexAttrib2hNV(index, x, y);}
void __stdcall _Lazy_glVertexAttrib2hvNV(GLuint index, const GLhalfNV * v) {if (GLeeInit()) glVertexAttrib2hvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib3hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z) {if (GLeeInit()) glVertexAttrib3hNV(index, x, y, z);}
void __stdcall _Lazy_glVertexAttrib3hvNV(GLuint index, const GLhalfNV * v) {if (GLeeInit()) glVertexAttrib3hvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib4hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w) {if (GLeeInit()) glVertexAttrib4hNV(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttrib4hvNV(GLuint index, const GLhalfNV * v) {if (GLeeInit()) glVertexAttrib4hvNV(index, v);}
void __stdcall _Lazy_glVertexAttribs1hvNV(GLuint index, GLsizei n, const GLhalfNV * v) {if (GLeeInit()) glVertexAttribs1hvNV(index, n, v);}
void __stdcall _Lazy_glVertexAttribs2hvNV(GLuint index, GLsizei n, const GLhalfNV * v) {if (GLeeInit()) glVertexAttribs2hvNV(index, n, v);}
void __stdcall _Lazy_glVertexAttribs3hvNV(GLuint index, GLsizei n, const GLhalfNV * v) {if (GLeeInit()) glVertexAttribs3hvNV(index, n, v);}
void __stdcall _Lazy_glVertexAttribs4hvNV(GLuint index, GLsizei n, const GLhalfNV * v) {if (GLeeInit()) glVertexAttribs4hvNV(index, n, v);}
PFNGLVERTEX2HNVPROC pglVertex2hNV=_Lazy_glVertex2hNV;
PFNGLVERTEX2HVNVPROC pglVertex2hvNV=_Lazy_glVertex2hvNV;
PFNGLVERTEX3HNVPROC pglVertex3hNV=_Lazy_glVertex3hNV;
PFNGLVERTEX3HVNVPROC pglVertex3hvNV=_Lazy_glVertex3hvNV;
PFNGLVERTEX4HNVPROC pglVertex4hNV=_Lazy_glVertex4hNV;
PFNGLVERTEX4HVNVPROC pglVertex4hvNV=_Lazy_glVertex4hvNV;
PFNGLNORMAL3HNVPROC pglNormal3hNV=_Lazy_glNormal3hNV;
PFNGLNORMAL3HVNVPROC pglNormal3hvNV=_Lazy_glNormal3hvNV;
PFNGLCOLOR3HNVPROC pglColor3hNV=_Lazy_glColor3hNV;
PFNGLCOLOR3HVNVPROC pglColor3hvNV=_Lazy_glColor3hvNV;
PFNGLCOLOR4HNVPROC pglColor4hNV=_Lazy_glColor4hNV;
PFNGLCOLOR4HVNVPROC pglColor4hvNV=_Lazy_glColor4hvNV;
PFNGLTEXCOORD1HNVPROC pglTexCoord1hNV=_Lazy_glTexCoord1hNV;
PFNGLTEXCOORD1HVNVPROC pglTexCoord1hvNV=_Lazy_glTexCoord1hvNV;
PFNGLTEXCOORD2HNVPROC pglTexCoord2hNV=_Lazy_glTexCoord2hNV;
PFNGLTEXCOORD2HVNVPROC pglTexCoord2hvNV=_Lazy_glTexCoord2hvNV;
PFNGLTEXCOORD3HNVPROC pglTexCoord3hNV=_Lazy_glTexCoord3hNV;
PFNGLTEXCOORD3HVNVPROC pglTexCoord3hvNV=_Lazy_glTexCoord3hvNV;
PFNGLTEXCOORD4HNVPROC pglTexCoord4hNV=_Lazy_glTexCoord4hNV;
PFNGLTEXCOORD4HVNVPROC pglTexCoord4hvNV=_Lazy_glTexCoord4hvNV;
PFNGLMULTITEXCOORD1HNVPROC pglMultiTexCoord1hNV=_Lazy_glMultiTexCoord1hNV;
PFNGLMULTITEXCOORD1HVNVPROC pglMultiTexCoord1hvNV=_Lazy_glMultiTexCoord1hvNV;
PFNGLMULTITEXCOORD2HNVPROC pglMultiTexCoord2hNV=_Lazy_glMultiTexCoord2hNV;
PFNGLMULTITEXCOORD2HVNVPROC pglMultiTexCoord2hvNV=_Lazy_glMultiTexCoord2hvNV;
PFNGLMULTITEXCOORD3HNVPROC pglMultiTexCoord3hNV=_Lazy_glMultiTexCoord3hNV;
PFNGLMULTITEXCOORD3HVNVPROC pglMultiTexCoord3hvNV=_Lazy_glMultiTexCoord3hvNV;
PFNGLMULTITEXCOORD4HNVPROC pglMultiTexCoord4hNV=_Lazy_glMultiTexCoord4hNV;
PFNGLMULTITEXCOORD4HVNVPROC pglMultiTexCoord4hvNV=_Lazy_glMultiTexCoord4hvNV;
PFNGLFOGCOORDHNVPROC pglFogCoordhNV=_Lazy_glFogCoordhNV;
PFNGLFOGCOORDHVNVPROC pglFogCoordhvNV=_Lazy_glFogCoordhvNV;
PFNGLSECONDARYCOLOR3HNVPROC pglSecondaryColor3hNV=_Lazy_glSecondaryColor3hNV;
PFNGLSECONDARYCOLOR3HVNVPROC pglSecondaryColor3hvNV=_Lazy_glSecondaryColor3hvNV;
PFNGLVERTEXWEIGHTHNVPROC pglVertexWeighthNV=_Lazy_glVertexWeighthNV;
PFNGLVERTEXWEIGHTHVNVPROC pglVertexWeighthvNV=_Lazy_glVertexWeighthvNV;
PFNGLVERTEXATTRIB1HNVPROC pglVertexAttrib1hNV=_Lazy_glVertexAttrib1hNV;
PFNGLVERTEXATTRIB1HVNVPROC pglVertexAttrib1hvNV=_Lazy_glVertexAttrib1hvNV;
PFNGLVERTEXATTRIB2HNVPROC pglVertexAttrib2hNV=_Lazy_glVertexAttrib2hNV;
PFNGLVERTEXATTRIB2HVNVPROC pglVertexAttrib2hvNV=_Lazy_glVertexAttrib2hvNV;
PFNGLVERTEXATTRIB3HNVPROC pglVertexAttrib3hNV=_Lazy_glVertexAttrib3hNV;
PFNGLVERTEXATTRIB3HVNVPROC pglVertexAttrib3hvNV=_Lazy_glVertexAttrib3hvNV;
PFNGLVERTEXATTRIB4HNVPROC pglVertexAttrib4hNV=_Lazy_glVertexAttrib4hNV;
PFNGLVERTEXATTRIB4HVNVPROC pglVertexAttrib4hvNV=_Lazy_glVertexAttrib4hvNV;
PFNGLVERTEXATTRIBS1HVNVPROC pglVertexAttribs1hvNV=_Lazy_glVertexAttribs1hvNV;
PFNGLVERTEXATTRIBS2HVNVPROC pglVertexAttribs2hvNV=_Lazy_glVertexAttribs2hvNV;
PFNGLVERTEXATTRIBS3HVNVPROC pglVertexAttribs3hvNV=_Lazy_glVertexAttribs3hvNV;
PFNGLVERTEXATTRIBS4HVNVPROC pglVertexAttribs4hvNV=_Lazy_glVertexAttribs4hvNV;
#endif
/* GL_NV_pixel_data_range */
#ifdef __GLEE_GL_NV_pixel_data_range
void __stdcall _Lazy_glPixelDataRangeNV(GLenum target, GLsizei length, GLvoid * pointer) {if (GLeeInit()) glPixelDataRangeNV(target, length, pointer);}
void __stdcall _Lazy_glFlushPixelDataRangeNV(GLenum target) {if (GLeeInit()) glFlushPixelDataRangeNV(target);}
PFNGLPIXELDATARANGENVPROC pglPixelDataRangeNV=_Lazy_glPixelDataRangeNV;
PFNGLFLUSHPIXELDATARANGENVPROC pglFlushPixelDataRangeNV=_Lazy_glFlushPixelDataRangeNV;
#endif
/* GL_NV_primitive_restart */
#ifdef __GLEE_GL_NV_primitive_restart
void __stdcall _Lazy_glPrimitiveRestartNV(void) {if (GLeeInit()) glPrimitiveRestartNV();}
void __stdcall _Lazy_glPrimitiveRestartIndexNV(GLuint index) {if (GLeeInit()) glPrimitiveRestartIndexNV(index);}
PFNGLPRIMITIVERESTARTNVPROC pglPrimitiveRestartNV=_Lazy_glPrimitiveRestartNV;
PFNGLPRIMITIVERESTARTINDEXNVPROC pglPrimitiveRestartIndexNV=_Lazy_glPrimitiveRestartIndexNV;
#endif
/* GL_NV_texture_expand_normal */
#ifdef __GLEE_GL_NV_texture_expand_normal
#endif
/* GL_NV_vertex_program2 */
#ifdef __GLEE_GL_NV_vertex_program2
#endif
/* GL_ATI_map_object_buffer */
#ifdef __GLEE_GL_ATI_map_object_buffer
GLvoid* __stdcall _Lazy_glMapObjectBufferATI(GLuint buffer) {if (GLeeInit()) return glMapObjectBufferATI(buffer); return (GLvoid*)0;}
void __stdcall _Lazy_glUnmapObjectBufferATI(GLuint buffer) {if (GLeeInit()) glUnmapObjectBufferATI(buffer);}
PFNGLMAPOBJECTBUFFERATIPROC pglMapObjectBufferATI=_Lazy_glMapObjectBufferATI;
PFNGLUNMAPOBJECTBUFFERATIPROC pglUnmapObjectBufferATI=_Lazy_glUnmapObjectBufferATI;
#endif
/* GL_ATI_separate_stencil */
#ifdef __GLEE_GL_ATI_separate_stencil
void __stdcall _Lazy_glStencilOpSeparateATI(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {if (GLeeInit()) glStencilOpSeparateATI(face, sfail, dpfail, dppass);}
void __stdcall _Lazy_glStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask) {if (GLeeInit()) glStencilFuncSeparateATI(frontfunc, backfunc, ref, mask);}
PFNGLSTENCILOPSEPARATEATIPROC pglStencilOpSeparateATI=_Lazy_glStencilOpSeparateATI;
PFNGLSTENCILFUNCSEPARATEATIPROC pglStencilFuncSeparateATI=_Lazy_glStencilFuncSeparateATI;
#endif
/* GL_ATI_vertex_attrib_array_object */
#ifdef __GLEE_GL_ATI_vertex_attrib_array_object
void __stdcall _Lazy_glVertexAttribArrayObjectATI(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset) {if (GLeeInit()) glVertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset);}
void __stdcall _Lazy_glGetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetVertexAttribArrayObjectfvATI(index, pname, params);}
void __stdcall _Lazy_glGetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, GLint * params) {if (GLeeInit()) glGetVertexAttribArrayObjectivATI(index, pname, params);}
PFNGLVERTEXATTRIBARRAYOBJECTATIPROC pglVertexAttribArrayObjectATI=_Lazy_glVertexAttribArrayObjectATI;
PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC pglGetVertexAttribArrayObjectfvATI=_Lazy_glGetVertexAttribArrayObjectfvATI;
PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC pglGetVertexAttribArrayObjectivATI=_Lazy_glGetVertexAttribArrayObjectivATI;
#endif
/* GL_OES_read_format */
#ifdef __GLEE_GL_OES_read_format
#endif
/* GL_EXT_depth_bounds_test */
#ifdef __GLEE_GL_EXT_depth_bounds_test
void __stdcall _Lazy_glDepthBoundsEXT(GLclampd zmin, GLclampd zmax) {if (GLeeInit()) glDepthBoundsEXT(zmin, zmax);}
PFNGLDEPTHBOUNDSEXTPROC pglDepthBoundsEXT=_Lazy_glDepthBoundsEXT;
#endif
/* GL_EXT_texture_mirror_clamp */
#ifdef __GLEE_GL_EXT_texture_mirror_clamp
#endif
/* GL_EXT_blend_equation_separate */
#ifdef __GLEE_GL_EXT_blend_equation_separate
void __stdcall _Lazy_glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeAlpha) {if (GLeeInit()) glBlendEquationSeparateEXT(modeRGB, modeAlpha);}
PFNGLBLENDEQUATIONSEPARATEEXTPROC pglBlendEquationSeparateEXT=_Lazy_glBlendEquationSeparateEXT;
#endif
/* GL_MESA_pack_invert */
#ifdef __GLEE_GL_MESA_pack_invert
#endif
/* GL_MESA_ycbcr_texture */
#ifdef __GLEE_GL_MESA_ycbcr_texture
#endif
/* GL_EXT_pixel_buffer_object */
#ifdef __GLEE_GL_EXT_pixel_buffer_object
#endif
/* GL_NV_fragment_program_option */
#ifdef __GLEE_GL_NV_fragment_program_option
#endif
/* GL_NV_fragment_program2 */
#ifdef __GLEE_GL_NV_fragment_program2
#endif
/* GL_NV_vertex_program2_option */
#ifdef __GLEE_GL_NV_vertex_program2_option
#endif
/* GL_NV_vertex_program3 */
#ifdef __GLEE_GL_NV_vertex_program3
#endif
/* GL_EXT_framebuffer_object */
#ifdef __GLEE_GL_EXT_framebuffer_object
GLboolean __stdcall _Lazy_glIsRenderbufferEXT(GLuint renderbuffer) {if (GLeeInit()) return glIsRenderbufferEXT(renderbuffer); return (GLboolean)0;}
void __stdcall _Lazy_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer) {if (GLeeInit()) glBindRenderbufferEXT(target, renderbuffer);}
void __stdcall _Lazy_glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers) {if (GLeeInit()) glDeleteRenderbuffersEXT(n, renderbuffers);}
void __stdcall _Lazy_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers) {if (GLeeInit()) glGenRenderbuffersEXT(n, renderbuffers);}
void __stdcall _Lazy_glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {if (GLeeInit()) glRenderbufferStorageEXT(target, internalformat, width, height);}
void __stdcall _Lazy_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetRenderbufferParameterivEXT(target, pname, params);}
GLboolean __stdcall _Lazy_glIsFramebufferEXT(GLuint framebuffer) {if (GLeeInit()) return glIsFramebufferEXT(framebuffer); return (GLboolean)0;}
void __stdcall _Lazy_glBindFramebufferEXT(GLenum target, GLuint framebuffer) {if (GLeeInit()) glBindFramebufferEXT(target, framebuffer);}
void __stdcall _Lazy_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers) {if (GLeeInit()) glDeleteFramebuffersEXT(n, framebuffers);}
void __stdcall _Lazy_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers) {if (GLeeInit()) glGenFramebuffersEXT(n, framebuffers);}
GLenum __stdcall _Lazy_glCheckFramebufferStatusEXT(GLenum target) {if (GLeeInit()) return glCheckFramebufferStatusEXT(target); return (GLenum)0;}
void __stdcall _Lazy_glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {if (GLeeInit()) glFramebufferTexture1DEXT(target, attachment, textarget, texture, level);}
void __stdcall _Lazy_glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {if (GLeeInit()) glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);}
void __stdcall _Lazy_glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {if (GLeeInit()) glFramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset);}
void __stdcall _Lazy_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {if (GLeeInit()) glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer);}
void __stdcall _Lazy_glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint * params) {if (GLeeInit()) glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);}
void __stdcall _Lazy_glGenerateMipmapEXT(GLenum target) {if (GLeeInit()) glGenerateMipmapEXT(target);}
PFNGLISRENDERBUFFEREXTPROC pglIsRenderbufferEXT=_Lazy_glIsRenderbufferEXT;
PFNGLBINDRENDERBUFFEREXTPROC pglBindRenderbufferEXT=_Lazy_glBindRenderbufferEXT;
PFNGLDELETERENDERBUFFERSEXTPROC pglDeleteRenderbuffersEXT=_Lazy_glDeleteRenderbuffersEXT;
PFNGLGENRENDERBUFFERSEXTPROC pglGenRenderbuffersEXT=_Lazy_glGenRenderbuffersEXT;
PFNGLRENDERBUFFERSTORAGEEXTPROC pglRenderbufferStorageEXT=_Lazy_glRenderbufferStorageEXT;
PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC pglGetRenderbufferParameterivEXT=_Lazy_glGetRenderbufferParameterivEXT;
PFNGLISFRAMEBUFFEREXTPROC pglIsFramebufferEXT=_Lazy_glIsFramebufferEXT;
PFNGLBINDFRAMEBUFFEREXTPROC pglBindFramebufferEXT=_Lazy_glBindFramebufferEXT;
PFNGLDELETEFRAMEBUFFERSEXTPROC pglDeleteFramebuffersEXT=_Lazy_glDeleteFramebuffersEXT;
PFNGLGENFRAMEBUFFERSEXTPROC pglGenFramebuffersEXT=_Lazy_glGenFramebuffersEXT;
PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC pglCheckFramebufferStatusEXT=_Lazy_glCheckFramebufferStatusEXT;
PFNGLFRAMEBUFFERTEXTURE1DEXTPROC pglFramebufferTexture1DEXT=_Lazy_glFramebufferTexture1DEXT;
PFNGLFRAMEBUFFERTEXTURE2DEXTPROC pglFramebufferTexture2DEXT=_Lazy_glFramebufferTexture2DEXT;
PFNGLFRAMEBUFFERTEXTURE3DEXTPROC pglFramebufferTexture3DEXT=_Lazy_glFramebufferTexture3DEXT;
PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC pglFramebufferRenderbufferEXT=_Lazy_glFramebufferRenderbufferEXT;
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC pglGetFramebufferAttachmentParameterivEXT=_Lazy_glGetFramebufferAttachmentParameterivEXT;
PFNGLGENERATEMIPMAPEXTPROC pglGenerateMipmapEXT=_Lazy_glGenerateMipmapEXT;
#endif
/* GL_GREMEDY_string_marker */
#ifdef __GLEE_GL_GREMEDY_string_marker
void __stdcall _Lazy_glStringMarkerGREMEDY(GLsizei len, const GLvoid * string) {if (GLeeInit()) glStringMarkerGREMEDY(len, string);}
PFNGLSTRINGMARKERGREMEDYPROC pglStringMarkerGREMEDY=_Lazy_glStringMarkerGREMEDY;
#endif
/* GL_EXT_packed_depth_stencil */
#ifdef __GLEE_GL_EXT_packed_depth_stencil
#endif
/* GL_EXT_stencil_clear_tag */
#ifdef __GLEE_GL_EXT_stencil_clear_tag
void __stdcall _Lazy_glStencilClearTagEXT(GLsizei stencilTagBits, GLuint stencilClearTag) {if (GLeeInit()) glStencilClearTagEXT(stencilTagBits, stencilClearTag);}
PFNGLSTENCILCLEARTAGEXTPROC pglStencilClearTagEXT=_Lazy_glStencilClearTagEXT;
#endif
/* GL_EXT_texture_sRGB */
#ifdef __GLEE_GL_EXT_texture_sRGB
#endif
/* GL_EXT_framebuffer_blit */
#ifdef __GLEE_GL_EXT_framebuffer_blit
void __stdcall _Lazy_glBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {if (GLeeInit()) glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);}
PFNGLBLITFRAMEBUFFEREXTPROC pglBlitFramebufferEXT=_Lazy_glBlitFramebufferEXT;
#endif
/* GL_EXT_framebuffer_multisample */
#ifdef __GLEE_GL_EXT_framebuffer_multisample
void __stdcall _Lazy_glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {if (GLeeInit()) glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);}
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC pglRenderbufferStorageMultisampleEXT=_Lazy_glRenderbufferStorageMultisampleEXT;
#endif
/* GL_MESAX_texture_stack */
#ifdef __GLEE_GL_MESAX_texture_stack
#endif
/* GL_EXT_timer_query */
#ifdef __GLEE_GL_EXT_timer_query
void __stdcall _Lazy_glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64EXT * params) {if (GLeeInit()) glGetQueryObjecti64vEXT(id, pname, params);}
void __stdcall _Lazy_glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64EXT * params) {if (GLeeInit()) glGetQueryObjectui64vEXT(id, pname, params);}
PFNGLGETQUERYOBJECTI64VEXTPROC pglGetQueryObjecti64vEXT=_Lazy_glGetQueryObjecti64vEXT;
PFNGLGETQUERYOBJECTUI64VEXTPROC pglGetQueryObjectui64vEXT=_Lazy_glGetQueryObjectui64vEXT;
#endif
/* GL_EXT_gpu_program_parameters */
#ifdef __GLEE_GL_EXT_gpu_program_parameters
void __stdcall _Lazy_glProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat * params) {if (GLeeInit()) glProgramEnvParameters4fvEXT(target, index, count, params);}
void __stdcall _Lazy_glProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat * params) {if (GLeeInit()) glProgramLocalParameters4fvEXT(target, index, count, params);}
PFNGLPROGRAMENVPARAMETERS4FVEXTPROC pglProgramEnvParameters4fvEXT=_Lazy_glProgramEnvParameters4fvEXT;
PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC pglProgramLocalParameters4fvEXT=_Lazy_glProgramLocalParameters4fvEXT;
#endif
/* GL_APPLE_flush_buffer_range */
#ifdef __GLEE_GL_APPLE_flush_buffer_range
void __stdcall _Lazy_glBufferParameteriAPPLE(GLenum target, GLenum pname, GLint param) {if (GLeeInit()) glBufferParameteriAPPLE(target, pname, param);}
void __stdcall _Lazy_glFlushMappedBufferRangeAPPLE(GLenum target, GLintptr offset, GLsizeiptr size) {if (GLeeInit()) glFlushMappedBufferRangeAPPLE(target, offset, size);}
PFNGLBUFFERPARAMETERIAPPLEPROC pglBufferParameteriAPPLE=_Lazy_glBufferParameteriAPPLE;
PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC pglFlushMappedBufferRangeAPPLE=_Lazy_glFlushMappedBufferRangeAPPLE;
#endif
/* GL_NV_gpu_program4 */
#ifdef __GLEE_GL_NV_gpu_program4
void __stdcall _Lazy_glProgramLocalParameterI4iNV(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glProgramLocalParameterI4iNV(target, index, x, y, z, w);}
void __stdcall _Lazy_glProgramLocalParameterI4ivNV(GLenum target, GLuint index, const GLint * params) {if (GLeeInit()) glProgramLocalParameterI4ivNV(target, index, params);}
void __stdcall _Lazy_glProgramLocalParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint * params) {if (GLeeInit()) glProgramLocalParametersI4ivNV(target, index, count, params);}
void __stdcall _Lazy_glProgramLocalParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {if (GLeeInit()) glProgramLocalParameterI4uiNV(target, index, x, y, z, w);}
void __stdcall _Lazy_glProgramLocalParameterI4uivNV(GLenum target, GLuint index, const GLuint * params) {if (GLeeInit()) glProgramLocalParameterI4uivNV(target, index, params);}
void __stdcall _Lazy_glProgramLocalParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint * params) {if (GLeeInit()) glProgramLocalParametersI4uivNV(target, index, count, params);}
void __stdcall _Lazy_glProgramEnvParameterI4iNV(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glProgramEnvParameterI4iNV(target, index, x, y, z, w);}
void __stdcall _Lazy_glProgramEnvParameterI4ivNV(GLenum target, GLuint index, const GLint * params) {if (GLeeInit()) glProgramEnvParameterI4ivNV(target, index, params);}
void __stdcall _Lazy_glProgramEnvParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint * params) {if (GLeeInit()) glProgramEnvParametersI4ivNV(target, index, count, params);}
void __stdcall _Lazy_glProgramEnvParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {if (GLeeInit()) glProgramEnvParameterI4uiNV(target, index, x, y, z, w);}
void __stdcall _Lazy_glProgramEnvParameterI4uivNV(GLenum target, GLuint index, const GLuint * params) {if (GLeeInit()) glProgramEnvParameterI4uivNV(target, index, params);}
void __stdcall _Lazy_glProgramEnvParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint * params) {if (GLeeInit()) glProgramEnvParametersI4uivNV(target, index, count, params);}
void __stdcall _Lazy_glGetProgramLocalParameterIivNV(GLenum target, GLuint index, GLint * params) {if (GLeeInit()) glGetProgramLocalParameterIivNV(target, index, params);}
void __stdcall _Lazy_glGetProgramLocalParameterIuivNV(GLenum target, GLuint index, GLuint * params) {if (GLeeInit()) glGetProgramLocalParameterIuivNV(target, index, params);}
void __stdcall _Lazy_glGetProgramEnvParameterIivNV(GLenum target, GLuint index, GLint * params) {if (GLeeInit()) glGetProgramEnvParameterIivNV(target, index, params);}
void __stdcall _Lazy_glGetProgramEnvParameterIuivNV(GLenum target, GLuint index, GLuint * params) {if (GLeeInit()) glGetProgramEnvParameterIuivNV(target, index, params);}
PFNGLPROGRAMLOCALPARAMETERI4INVPROC pglProgramLocalParameterI4iNV=_Lazy_glProgramLocalParameterI4iNV;
PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC pglProgramLocalParameterI4ivNV=_Lazy_glProgramLocalParameterI4ivNV;
PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC pglProgramLocalParametersI4ivNV=_Lazy_glProgramLocalParametersI4ivNV;
PFNGLPROGRAMLOCALPARAMETERI4UINVPROC pglProgramLocalParameterI4uiNV=_Lazy_glProgramLocalParameterI4uiNV;
PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC pglProgramLocalParameterI4uivNV=_Lazy_glProgramLocalParameterI4uivNV;
PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC pglProgramLocalParametersI4uivNV=_Lazy_glProgramLocalParametersI4uivNV;
PFNGLPROGRAMENVPARAMETERI4INVPROC pglProgramEnvParameterI4iNV=_Lazy_glProgramEnvParameterI4iNV;
PFNGLPROGRAMENVPARAMETERI4IVNVPROC pglProgramEnvParameterI4ivNV=_Lazy_glProgramEnvParameterI4ivNV;
PFNGLPROGRAMENVPARAMETERSI4IVNVPROC pglProgramEnvParametersI4ivNV=_Lazy_glProgramEnvParametersI4ivNV;
PFNGLPROGRAMENVPARAMETERI4UINVPROC pglProgramEnvParameterI4uiNV=_Lazy_glProgramEnvParameterI4uiNV;
PFNGLPROGRAMENVPARAMETERI4UIVNVPROC pglProgramEnvParameterI4uivNV=_Lazy_glProgramEnvParameterI4uivNV;
PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC pglProgramEnvParametersI4uivNV=_Lazy_glProgramEnvParametersI4uivNV;
PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC pglGetProgramLocalParameterIivNV=_Lazy_glGetProgramLocalParameterIivNV;
PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC pglGetProgramLocalParameterIuivNV=_Lazy_glGetProgramLocalParameterIuivNV;
PFNGLGETPROGRAMENVPARAMETERIIVNVPROC pglGetProgramEnvParameterIivNV=_Lazy_glGetProgramEnvParameterIivNV;
PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC pglGetProgramEnvParameterIuivNV=_Lazy_glGetProgramEnvParameterIuivNV;
#endif
/* GL_NV_geometry_program4 */
#ifdef __GLEE_GL_NV_geometry_program4
void __stdcall _Lazy_glProgramVertexLimitNV(GLenum target, GLint limit) {if (GLeeInit()) glProgramVertexLimitNV(target, limit);}
void __stdcall _Lazy_glFramebufferTextureEXT(GLenum target, GLenum attachment, GLuint texture, GLint level) {if (GLeeInit()) glFramebufferTextureEXT(target, attachment, texture, level);}
void __stdcall _Lazy_glFramebufferTextureLayerEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {if (GLeeInit()) glFramebufferTextureLayerEXT(target, attachment, texture, level, layer);}
void __stdcall _Lazy_glFramebufferTextureFaceEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face) {if (GLeeInit()) glFramebufferTextureFaceEXT(target, attachment, texture, level, face);}
PFNGLPROGRAMVERTEXLIMITNVPROC pglProgramVertexLimitNV=_Lazy_glProgramVertexLimitNV;
PFNGLFRAMEBUFFERTEXTUREEXTPROC pglFramebufferTextureEXT=_Lazy_glFramebufferTextureEXT;
PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC pglFramebufferTextureLayerEXT=_Lazy_glFramebufferTextureLayerEXT;
PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC pglFramebufferTextureFaceEXT=_Lazy_glFramebufferTextureFaceEXT;
#endif
/* GL_EXT_geometry_shader4 */
#ifdef __GLEE_GL_EXT_geometry_shader4
void __stdcall _Lazy_glProgramParameteriEXT(GLuint program, GLenum pname, GLint value) {if (GLeeInit()) glProgramParameteriEXT(program, pname, value);}
PFNGLPROGRAMPARAMETERIEXTPROC pglProgramParameteriEXT=_Lazy_glProgramParameteriEXT;
#endif
/* GL_NV_vertex_program4 */
#ifdef __GLEE_GL_NV_vertex_program4
void __stdcall _Lazy_glVertexAttribI1iEXT(GLuint index, GLint x) {if (GLeeInit()) glVertexAttribI1iEXT(index, x);}
void __stdcall _Lazy_glVertexAttribI2iEXT(GLuint index, GLint x, GLint y) {if (GLeeInit()) glVertexAttribI2iEXT(index, x, y);}
void __stdcall _Lazy_glVertexAttribI3iEXT(GLuint index, GLint x, GLint y, GLint z) {if (GLeeInit()) glVertexAttribI3iEXT(index, x, y, z);}
void __stdcall _Lazy_glVertexAttribI4iEXT(GLuint index, GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glVertexAttribI4iEXT(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttribI1uiEXT(GLuint index, GLuint x) {if (GLeeInit()) glVertexAttribI1uiEXT(index, x);}
void __stdcall _Lazy_glVertexAttribI2uiEXT(GLuint index, GLuint x, GLuint y) {if (GLeeInit()) glVertexAttribI2uiEXT(index, x, y);}
void __stdcall _Lazy_glVertexAttribI3uiEXT(GLuint index, GLuint x, GLuint y, GLuint z) {if (GLeeInit()) glVertexAttribI3uiEXT(index, x, y, z);}
void __stdcall _Lazy_glVertexAttribI4uiEXT(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {if (GLeeInit()) glVertexAttribI4uiEXT(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttribI1ivEXT(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttribI1ivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI2ivEXT(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttribI2ivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI3ivEXT(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttribI3ivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI4ivEXT(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttribI4ivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI1uivEXT(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttribI1uivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI2uivEXT(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttribI2uivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI3uivEXT(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttribI3uivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI4uivEXT(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttribI4uivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI4bvEXT(GLuint index, const GLbyte * v) {if (GLeeInit()) glVertexAttribI4bvEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI4svEXT(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttribI4svEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI4ubvEXT(GLuint index, const GLubyte * v) {if (GLeeInit()) glVertexAttribI4ubvEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI4usvEXT(GLuint index, const GLushort * v) {if (GLeeInit()) glVertexAttribI4usvEXT(index, v);}
void __stdcall _Lazy_glVertexAttribIPointerEXT(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glVertexAttribIPointerEXT(index, size, type, stride, pointer);}
void __stdcall _Lazy_glGetVertexAttribIivEXT(GLuint index, GLenum pname, GLint * params) {if (GLeeInit()) glGetVertexAttribIivEXT(index, pname, params);}
void __stdcall _Lazy_glGetVertexAttribIuivEXT(GLuint index, GLenum pname, GLuint * params) {if (GLeeInit()) glGetVertexAttribIuivEXT(index, pname, params);}
PFNGLVERTEXATTRIBI1IEXTPROC pglVertexAttribI1iEXT=_Lazy_glVertexAttribI1iEXT;
PFNGLVERTEXATTRIBI2IEXTPROC pglVertexAttribI2iEXT=_Lazy_glVertexAttribI2iEXT;
PFNGLVERTEXATTRIBI3IEXTPROC pglVertexAttribI3iEXT=_Lazy_glVertexAttribI3iEXT;
PFNGLVERTEXATTRIBI4IEXTPROC pglVertexAttribI4iEXT=_Lazy_glVertexAttribI4iEXT;
PFNGLVERTEXATTRIBI1UIEXTPROC pglVertexAttribI1uiEXT=_Lazy_glVertexAttribI1uiEXT;
PFNGLVERTEXATTRIBI2UIEXTPROC pglVertexAttribI2uiEXT=_Lazy_glVertexAttribI2uiEXT;
PFNGLVERTEXATTRIBI3UIEXTPROC pglVertexAttribI3uiEXT=_Lazy_glVertexAttribI3uiEXT;
PFNGLVERTEXATTRIBI4UIEXTPROC pglVertexAttribI4uiEXT=_Lazy_glVertexAttribI4uiEXT;
PFNGLVERTEXATTRIBI1IVEXTPROC pglVertexAttribI1ivEXT=_Lazy_glVertexAttribI1ivEXT;
PFNGLVERTEXATTRIBI2IVEXTPROC pglVertexAttribI2ivEXT=_Lazy_glVertexAttribI2ivEXT;
PFNGLVERTEXATTRIBI3IVEXTPROC pglVertexAttribI3ivEXT=_Lazy_glVertexAttribI3ivEXT;
PFNGLVERTEXATTRIBI4IVEXTPROC pglVertexAttribI4ivEXT=_Lazy_glVertexAttribI4ivEXT;
PFNGLVERTEXATTRIBI1UIVEXTPROC pglVertexAttribI1uivEXT=_Lazy_glVertexAttribI1uivEXT;
PFNGLVERTEXATTRIBI2UIVEXTPROC pglVertexAttribI2uivEXT=_Lazy_glVertexAttribI2uivEXT;
PFNGLVERTEXATTRIBI3UIVEXTPROC pglVertexAttribI3uivEXT=_Lazy_glVertexAttribI3uivEXT;
PFNGLVERTEXATTRIBI4UIVEXTPROC pglVertexAttribI4uivEXT=_Lazy_glVertexAttribI4uivEXT;
PFNGLVERTEXATTRIBI4BVEXTPROC pglVertexAttribI4bvEXT=_Lazy_glVertexAttribI4bvEXT;
PFNGLVERTEXATTRIBI4SVEXTPROC pglVertexAttribI4svEXT=_Lazy_glVertexAttribI4svEXT;
PFNGLVERTEXATTRIBI4UBVEXTPROC pglVertexAttribI4ubvEXT=_Lazy_glVertexAttribI4ubvEXT;
PFNGLVERTEXATTRIBI4USVEXTPROC pglVertexAttribI4usvEXT=_Lazy_glVertexAttribI4usvEXT;
PFNGLVERTEXATTRIBIPOINTEREXTPROC pglVertexAttribIPointerEXT=_Lazy_glVertexAttribIPointerEXT;
PFNGLGETVERTEXATTRIBIIVEXTPROC pglGetVertexAttribIivEXT=_Lazy_glGetVertexAttribIivEXT;
PFNGLGETVERTEXATTRIBIUIVEXTPROC pglGetVertexAttribIuivEXT=_Lazy_glGetVertexAttribIuivEXT;
#endif
/* GL_EXT_gpu_shader4 */
#ifdef __GLEE_GL_EXT_gpu_shader4
void __stdcall _Lazy_glGetUniformuivEXT(GLuint program, GLint location, GLuint * params) {if (GLeeInit()) glGetUniformuivEXT(program, location, params);}
void __stdcall _Lazy_glBindFragDataLocationEXT(GLuint program, GLuint color, const GLchar * name) {if (GLeeInit()) glBindFragDataLocationEXT(program, color, name);}
GLint __stdcall _Lazy_glGetFragDataLocationEXT(GLuint program, const GLchar * name) {if (GLeeInit()) return glGetFragDataLocationEXT(program, name); return (GLint)0;}
void __stdcall _Lazy_glUniform1uiEXT(GLint location, GLuint v0) {if (GLeeInit()) glUniform1uiEXT(location, v0);}
void __stdcall _Lazy_glUniform2uiEXT(GLint location, GLuint v0, GLuint v1) {if (GLeeInit()) glUniform2uiEXT(location, v0, v1);}
void __stdcall _Lazy_glUniform3uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2) {if (GLeeInit()) glUniform3uiEXT(location, v0, v1, v2);}
void __stdcall _Lazy_glUniform4uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {if (GLeeInit()) glUniform4uiEXT(location, v0, v1, v2, v3);}
void __stdcall _Lazy_glUniform1uivEXT(GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glUniform1uivEXT(location, count, value);}
void __stdcall _Lazy_glUniform2uivEXT(GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glUniform2uivEXT(location, count, value);}
void __stdcall _Lazy_glUniform3uivEXT(GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glUniform3uivEXT(location, count, value);}
void __stdcall _Lazy_glUniform4uivEXT(GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glUniform4uivEXT(location, count, value);}
PFNGLGETUNIFORMUIVEXTPROC pglGetUniformuivEXT=_Lazy_glGetUniformuivEXT;
PFNGLBINDFRAGDATALOCATIONEXTPROC pglBindFragDataLocationEXT=_Lazy_glBindFragDataLocationEXT;
PFNGLGETFRAGDATALOCATIONEXTPROC pglGetFragDataLocationEXT=_Lazy_glGetFragDataLocationEXT;
PFNGLUNIFORM1UIEXTPROC pglUniform1uiEXT=_Lazy_glUniform1uiEXT;
PFNGLUNIFORM2UIEXTPROC pglUniform2uiEXT=_Lazy_glUniform2uiEXT;
PFNGLUNIFORM3UIEXTPROC pglUniform3uiEXT=_Lazy_glUniform3uiEXT;
PFNGLUNIFORM4UIEXTPROC pglUniform4uiEXT=_Lazy_glUniform4uiEXT;
PFNGLUNIFORM1UIVEXTPROC pglUniform1uivEXT=_Lazy_glUniform1uivEXT;
PFNGLUNIFORM2UIVEXTPROC pglUniform2uivEXT=_Lazy_glUniform2uivEXT;
PFNGLUNIFORM3UIVEXTPROC pglUniform3uivEXT=_Lazy_glUniform3uivEXT;
PFNGLUNIFORM4UIVEXTPROC pglUniform4uivEXT=_Lazy_glUniform4uivEXT;
#endif
/* GL_EXT_draw_instanced */
#ifdef __GLEE_GL_EXT_draw_instanced
void __stdcall _Lazy_glDrawArraysInstancedEXT(GLenum mode, GLint start, GLsizei count, GLsizei primcount) {if (GLeeInit()) glDrawArraysInstancedEXT(mode, start, count, primcount);}
void __stdcall _Lazy_glDrawElementsInstancedEXT(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount) {if (GLeeInit()) glDrawElementsInstancedEXT(mode, count, type, indices, primcount);}
PFNGLDRAWARRAYSINSTANCEDEXTPROC pglDrawArraysInstancedEXT=_Lazy_glDrawArraysInstancedEXT;
PFNGLDRAWELEMENTSINSTANCEDEXTPROC pglDrawElementsInstancedEXT=_Lazy_glDrawElementsInstancedEXT;
#endif
/* GL_EXT_packed_float */
#ifdef __GLEE_GL_EXT_packed_float
#endif
/* GL_EXT_texture_array */
#ifdef __GLEE_GL_EXT_texture_array
#endif
/* GL_EXT_texture_buffer_object */
#ifdef __GLEE_GL_EXT_texture_buffer_object
void __stdcall _Lazy_glTexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer) {if (GLeeInit()) glTexBufferEXT(target, internalformat, buffer);}
PFNGLTEXBUFFEREXTPROC pglTexBufferEXT=_Lazy_glTexBufferEXT;
#endif
/* GL_EXT_texture_compression_latc */
#ifdef __GLEE_GL_EXT_texture_compression_latc
#endif
/* GL_EXT_texture_compression_rgtc */
#ifdef __GLEE_GL_EXT_texture_compression_rgtc
#endif
/* GL_EXT_texture_shared_exponent */
#ifdef __GLEE_GL_EXT_texture_shared_exponent
#endif
/* GL_NV_depth_buffer_float */
#ifdef __GLEE_GL_NV_depth_buffer_float
void __stdcall _Lazy_glDepthRangedNV(GLdouble zNear, GLdouble zFar) {if (GLeeInit()) glDepthRangedNV(zNear, zFar);}
void __stdcall _Lazy_glClearDepthdNV(GLdouble depth) {if (GLeeInit()) glClearDepthdNV(depth);}
void __stdcall _Lazy_glDepthBoundsdNV(GLdouble zmin, GLdouble zmax) {if (GLeeInit()) glDepthBoundsdNV(zmin, zmax);}
PFNGLDEPTHRANGEDNVPROC pglDepthRangedNV=_Lazy_glDepthRangedNV;
PFNGLCLEARDEPTHDNVPROC pglClearDepthdNV=_Lazy_glClearDepthdNV;
PFNGLDEPTHBOUNDSDNVPROC pglDepthBoundsdNV=_Lazy_glDepthBoundsdNV;
#endif
/* GL_NV_fragment_program4 */
#ifdef __GLEE_GL_NV_fragment_program4
#endif
/* GL_NV_framebuffer_multisample_coverage */
#ifdef __GLEE_GL_NV_framebuffer_multisample_coverage
void __stdcall _Lazy_glRenderbufferStorageMultisampleCoverageNV(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height) {if (GLeeInit()) glRenderbufferStorageMultisampleCoverageNV(target, coverageSamples, colorSamples, internalformat, width, height);}
PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC pglRenderbufferStorageMultisampleCoverageNV=_Lazy_glRenderbufferStorageMultisampleCoverageNV;
#endif
/* GL_EXT_framebuffer_sRGB */
#ifdef __GLEE_GL_EXT_framebuffer_sRGB
#endif
/* GL_NV_geometry_shader4 */
#ifdef __GLEE_GL_NV_geometry_shader4
#endif
/* GL_NV_parameter_buffer_object */
#ifdef __GLEE_GL_NV_parameter_buffer_object
void __stdcall _Lazy_glProgramBufferParametersfvNV(GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat * params) {if (GLeeInit()) glProgramBufferParametersfvNV(target, buffer, index, count, params);}
void __stdcall _Lazy_glProgramBufferParametersIivNV(GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint * params) {if (GLeeInit()) glProgramBufferParametersIivNV(target, buffer, index, count, params);}
void __stdcall _Lazy_glProgramBufferParametersIuivNV(GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint * params) {if (GLeeInit()) glProgramBufferParametersIuivNV(target, buffer, index, count, params);}
PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC pglProgramBufferParametersfvNV=_Lazy_glProgramBufferParametersfvNV;
PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC pglProgramBufferParametersIivNV=_Lazy_glProgramBufferParametersIivNV;
PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC pglProgramBufferParametersIuivNV=_Lazy_glProgramBufferParametersIuivNV;
#endif
/* GL_EXT_draw_buffers2 */
#ifdef __GLEE_GL_EXT_draw_buffers2
void __stdcall _Lazy_glColorMaskIndexedEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) {if (GLeeInit()) glColorMaskIndexedEXT(index, r, g, b, a);}
void __stdcall _Lazy_glGetBooleanIndexedvEXT(GLenum target, GLuint index, GLboolean * data) {if (GLeeInit()) glGetBooleanIndexedvEXT(target, index, data);}
void __stdcall _Lazy_glGetIntegerIndexedvEXT(GLenum target, GLuint index, GLint * data) {if (GLeeInit()) glGetIntegerIndexedvEXT(target, index, data);}
void __stdcall _Lazy_glEnableIndexedEXT(GLenum target, GLuint index) {if (GLeeInit()) glEnableIndexedEXT(target, index);}
void __stdcall _Lazy_glDisableIndexedEXT(GLenum target, GLuint index) {if (GLeeInit()) glDisableIndexedEXT(target, index);}
GLboolean __stdcall _Lazy_glIsEnabledIndexedEXT(GLenum target, GLuint index) {if (GLeeInit()) return glIsEnabledIndexedEXT(target, index); return (GLboolean)0;}
PFNGLCOLORMASKINDEXEDEXTPROC pglColorMaskIndexedEXT=_Lazy_glColorMaskIndexedEXT;
PFNGLGETBOOLEANINDEXEDVEXTPROC pglGetBooleanIndexedvEXT=_Lazy_glGetBooleanIndexedvEXT;
PFNGLGETINTEGERINDEXEDVEXTPROC pglGetIntegerIndexedvEXT=_Lazy_glGetIntegerIndexedvEXT;
PFNGLENABLEINDEXEDEXTPROC pglEnableIndexedEXT=_Lazy_glEnableIndexedEXT;
PFNGLDISABLEINDEXEDEXTPROC pglDisableIndexedEXT=_Lazy_glDisableIndexedEXT;
PFNGLISENABLEDINDEXEDEXTPROC pglIsEnabledIndexedEXT=_Lazy_glIsEnabledIndexedEXT;
#endif
/* GL_NV_transform_feedback */
#ifdef __GLEE_GL_NV_transform_feedback
void __stdcall _Lazy_glBeginTransformFeedbackNV(GLenum primitiveMode) {if (GLeeInit()) glBeginTransformFeedbackNV(primitiveMode);}
void __stdcall _Lazy_glEndTransformFeedbackNV(void) {if (GLeeInit()) glEndTransformFeedbackNV();}
void __stdcall _Lazy_glTransformFeedbackAttribsNV(GLuint count, const GLint * attribs, GLenum bufferMode) {if (GLeeInit()) glTransformFeedbackAttribsNV(count, attribs, bufferMode);}
void __stdcall _Lazy_glBindBufferRangeNV(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {if (GLeeInit()) glBindBufferRangeNV(target, index, buffer, offset, size);}
void __stdcall _Lazy_glBindBufferOffsetNV(GLenum target, GLuint index, GLuint buffer, GLintptr offset) {if (GLeeInit()) glBindBufferOffsetNV(target, index, buffer, offset);}
void __stdcall _Lazy_glBindBufferBaseNV(GLenum target, GLuint index, GLuint buffer) {if (GLeeInit()) glBindBufferBaseNV(target, index, buffer);}
void __stdcall _Lazy_glTransformFeedbackVaryingsNV(GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode) {if (GLeeInit()) glTransformFeedbackVaryingsNV(program, count, locations, bufferMode);}
void __stdcall _Lazy_glActiveVaryingNV(GLuint program, const GLchar * name) {if (GLeeInit()) glActiveVaryingNV(program, name);}
GLint __stdcall _Lazy_glGetVaryingLocationNV(GLuint program, const GLchar * name) {if (GLeeInit()) return glGetVaryingLocationNV(program, name); return (GLint)0;}
void __stdcall _Lazy_glGetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name) {if (GLeeInit()) glGetActiveVaryingNV(program, index, bufSize, length, size, type, name);}
void __stdcall _Lazy_glGetTransformFeedbackVaryingNV(GLuint program, GLuint index, GLint * location) {if (GLeeInit()) glGetTransformFeedbackVaryingNV(program, index, location);}
PFNGLBEGINTRANSFORMFEEDBACKNVPROC pglBeginTransformFeedbackNV=_Lazy_glBeginTransformFeedbackNV;
PFNGLENDTRANSFORMFEEDBACKNVPROC pglEndTransformFeedbackNV=_Lazy_glEndTransformFeedbackNV;
PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC pglTransformFeedbackAttribsNV=_Lazy_glTransformFeedbackAttribsNV;
PFNGLBINDBUFFERRANGENVPROC pglBindBufferRangeNV=_Lazy_glBindBufferRangeNV;
PFNGLBINDBUFFEROFFSETNVPROC pglBindBufferOffsetNV=_Lazy_glBindBufferOffsetNV;
PFNGLBINDBUFFERBASENVPROC pglBindBufferBaseNV=_Lazy_glBindBufferBaseNV;
PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC pglTransformFeedbackVaryingsNV=_Lazy_glTransformFeedbackVaryingsNV;
PFNGLACTIVEVARYINGNVPROC pglActiveVaryingNV=_Lazy_glActiveVaryingNV;
PFNGLGETVARYINGLOCATIONNVPROC pglGetVaryingLocationNV=_Lazy_glGetVaryingLocationNV;
PFNGLGETACTIVEVARYINGNVPROC pglGetActiveVaryingNV=_Lazy_glGetActiveVaryingNV;
PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC pglGetTransformFeedbackVaryingNV=_Lazy_glGetTransformFeedbackVaryingNV;
#endif
/* GL_EXT_bindable_uniform */
#ifdef __GLEE_GL_EXT_bindable_uniform
void __stdcall _Lazy_glUniformBufferEXT(GLuint program, GLint location, GLuint buffer) {if (GLeeInit()) glUniformBufferEXT(program, location, buffer);}
GLint __stdcall _Lazy_glGetUniformBufferSizeEXT(GLuint program, GLint location) {if (GLeeInit()) return glGetUniformBufferSizeEXT(program, location); return (GLint)0;}
GLintptr __stdcall _Lazy_glGetUniformOffsetEXT(GLuint program, GLint location) {if (GLeeInit()) return glGetUniformOffsetEXT(program, location); return (GLintptr)0;}
PFNGLUNIFORMBUFFEREXTPROC pglUniformBufferEXT=_Lazy_glUniformBufferEXT;
PFNGLGETUNIFORMBUFFERSIZEEXTPROC pglGetUniformBufferSizeEXT=_Lazy_glGetUniformBufferSizeEXT;
PFNGLGETUNIFORMOFFSETEXTPROC pglGetUniformOffsetEXT=_Lazy_glGetUniformOffsetEXT;
#endif
/* GL_EXT_texture_integer */
#ifdef __GLEE_GL_EXT_texture_integer
void __stdcall _Lazy_glTexParameterIivEXT(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glTexParameterIivEXT(target, pname, params);}
void __stdcall _Lazy_glTexParameterIuivEXT(GLenum target, GLenum pname, const GLuint * params) {if (GLeeInit()) glTexParameterIuivEXT(target, pname, params);}
void __stdcall _Lazy_glGetTexParameterIivEXT(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetTexParameterIivEXT(target, pname, params);}
void __stdcall _Lazy_glGetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint * params) {if (GLeeInit()) glGetTexParameterIuivEXT(target, pname, params);}
void __stdcall _Lazy_glClearColorIiEXT(GLint red, GLint green, GLint blue, GLint alpha) {if (GLeeInit()) glClearColorIiEXT(red, green, blue, alpha);}
void __stdcall _Lazy_glClearColorIuiEXT(GLuint red, GLuint green, GLuint blue, GLuint alpha) {if (GLeeInit()) glClearColorIuiEXT(red, green, blue, alpha);}
PFNGLTEXPARAMETERIIVEXTPROC pglTexParameterIivEXT=_Lazy_glTexParameterIivEXT;
PFNGLTEXPARAMETERIUIVEXTPROC pglTexParameterIuivEXT=_Lazy_glTexParameterIuivEXT;
PFNGLGETTEXPARAMETERIIVEXTPROC pglGetTexParameterIivEXT=_Lazy_glGetTexParameterIivEXT;
PFNGLGETTEXPARAMETERIUIVEXTPROC pglGetTexParameterIuivEXT=_Lazy_glGetTexParameterIuivEXT;
PFNGLCLEARCOLORIIEXTPROC pglClearColorIiEXT=_Lazy_glClearColorIiEXT;
PFNGLCLEARCOLORIUIEXTPROC pglClearColorIuiEXT=_Lazy_glClearColorIuiEXT;
#endif
/* GL_GREMEDY_frame_terminator */
#ifdef __GLEE_GL_GREMEDY_frame_terminator
void __stdcall _Lazy_glFrameTerminatorGREMEDY(void) {if (GLeeInit()) glFrameTerminatorGREMEDY();}
PFNGLFRAMETERMINATORGREMEDYPROC pglFrameTerminatorGREMEDY=_Lazy_glFrameTerminatorGREMEDY;
#endif
/* GL_NV_conditional_render */
#ifdef __GLEE_GL_NV_conditional_render
void __stdcall _Lazy_glBeginConditionalRenderNV(GLuint id, GLenum mode) {if (GLeeInit()) glBeginConditionalRenderNV(id, mode);}
void __stdcall _Lazy_glEndConditionalRenderNV(void) {if (GLeeInit()) glEndConditionalRenderNV();}
PFNGLBEGINCONDITIONALRENDERNVPROC pglBeginConditionalRenderNV=_Lazy_glBeginConditionalRenderNV;
PFNGLENDCONDITIONALRENDERNVPROC pglEndConditionalRenderNV=_Lazy_glEndConditionalRenderNV;
#endif
/* GL_NV_present_video */
#ifdef __GLEE_GL_NV_present_video
#endif
/* GL_EXT_transform_feedback */
#ifdef __GLEE_GL_EXT_transform_feedback
void __stdcall _Lazy_glBeginTransformFeedbackEXT(GLenum primitiveMode) {if (GLeeInit()) glBeginTransformFeedbackEXT(primitiveMode);}
void __stdcall _Lazy_glEndTransformFeedbackEXT(void) {if (GLeeInit()) glEndTransformFeedbackEXT();}
void __stdcall _Lazy_glBindBufferRangeEXT(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {if (GLeeInit()) glBindBufferRangeEXT(target, index, buffer, offset, size);}
void __stdcall _Lazy_glBindBufferOffsetEXT(GLenum target, GLuint index, GLuint buffer, GLintptr offset) {if (GLeeInit()) glBindBufferOffsetEXT(target, index, buffer, offset);}
void __stdcall _Lazy_glBindBufferBaseEXT(GLenum target, GLuint index, GLuint buffer) {if (GLeeInit()) glBindBufferBaseEXT(target, index, buffer);}
void __stdcall _Lazy_glTransformFeedbackVaryingsEXT(GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode) {if (GLeeInit()) glTransformFeedbackVaryingsEXT(program, count, locations, bufferMode);}
void __stdcall _Lazy_glGetTransformFeedbackVaryingEXT(GLuint program, GLuint index, GLint * location) {if (GLeeInit()) glGetTransformFeedbackVaryingEXT(program, index, location);}
PFNGLBEGINTRANSFORMFEEDBACKEXTPROC pglBeginTransformFeedbackEXT=_Lazy_glBeginTransformFeedbackEXT;
PFNGLENDTRANSFORMFEEDBACKEXTPROC pglEndTransformFeedbackEXT=_Lazy_glEndTransformFeedbackEXT;
PFNGLBINDBUFFERRANGEEXTPROC pglBindBufferRangeEXT=_Lazy_glBindBufferRangeEXT;
PFNGLBINDBUFFEROFFSETEXTPROC pglBindBufferOffsetEXT=_Lazy_glBindBufferOffsetEXT;
PFNGLBINDBUFFERBASEEXTPROC pglBindBufferBaseEXT=_Lazy_glBindBufferBaseEXT;
PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC pglTransformFeedbackVaryingsEXT=_Lazy_glTransformFeedbackVaryingsEXT;
PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC pglGetTransformFeedbackVaryingEXT=_Lazy_glGetTransformFeedbackVaryingEXT;
#endif
/* GL_EXT_direct_state_access */
#ifdef __GLEE_GL_EXT_direct_state_access
void __stdcall _Lazy_glClientAttribDefaultEXT(GLbitfield mask) {if (GLeeInit()) glClientAttribDefaultEXT(mask);}
void __stdcall _Lazy_glPushClientAttribDefaultEXT(GLbitfield mask) {if (GLeeInit()) glPushClientAttribDefaultEXT(mask);}
void __stdcall _Lazy_glMatrixLoadfEXT(GLenum mode, const GLfloat * m) {if (GLeeInit()) glMatrixLoadfEXT(mode, m);}
void __stdcall _Lazy_glMatrixLoaddEXT(GLenum mode, const GLdouble * m) {if (GLeeInit()) glMatrixLoaddEXT(mode, m);}
void __stdcall _Lazy_glMatrixMultfEXT(GLenum mode, const GLfloat * m) {if (GLeeInit()) glMatrixMultfEXT(mode, m);}
void __stdcall _Lazy_glMatrixMultdEXT(GLenum mode, const GLdouble * m) {if (GLeeInit()) glMatrixMultdEXT(mode, m);}
void __stdcall _Lazy_glMatrixLoadIdentityEXT(GLenum mode) {if (GLeeInit()) glMatrixLoadIdentityEXT(mode);}
void __stdcall _Lazy_glMatrixRotatefEXT(GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glMatrixRotatefEXT(mode, angle, x, y, z);}
void __stdcall _Lazy_glMatrixRotatedEXT(GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glMatrixRotatedEXT(mode, angle, x, y, z);}
void __stdcall _Lazy_glMatrixScalefEXT(GLenum mode, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glMatrixScalefEXT(mode, x, y, z);}
void __stdcall _Lazy_glMatrixScaledEXT(GLenum mode, GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glMatrixScaledEXT(mode, x, y, z);}
void __stdcall _Lazy_glMatrixTranslatefEXT(GLenum mode, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glMatrixTranslatefEXT(mode, x, y, z);}
void __stdcall _Lazy_glMatrixTranslatedEXT(GLenum mode, GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glMatrixTranslatedEXT(mode, x, y, z);}
void __stdcall _Lazy_glMatrixFrustumEXT(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {if (GLeeInit()) glMatrixFrustumEXT(mode, left, right, bottom, top, zNear, zFar);}
void __stdcall _Lazy_glMatrixOrthoEXT(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {if (GLeeInit()) glMatrixOrthoEXT(mode, left, right, bottom, top, zNear, zFar);}
void __stdcall _Lazy_glMatrixPopEXT(GLenum mode) {if (GLeeInit()) glMatrixPopEXT(mode);}
void __stdcall _Lazy_glMatrixPushEXT(GLenum mode) {if (GLeeInit()) glMatrixPushEXT(mode);}
void __stdcall _Lazy_glMatrixLoadTransposefEXT(GLenum mode, const GLfloat * m) {if (GLeeInit()) glMatrixLoadTransposefEXT(mode, m);}
void __stdcall _Lazy_glMatrixLoadTransposedEXT(GLenum mode, const GLdouble * m) {if (GLeeInit()) glMatrixLoadTransposedEXT(mode, m);}
void __stdcall _Lazy_glMatrixMultTransposefEXT(GLenum mode, const GLfloat * m) {if (GLeeInit()) glMatrixMultTransposefEXT(mode, m);}
void __stdcall _Lazy_glMatrixMultTransposedEXT(GLenum mode, const GLdouble * m) {if (GLeeInit()) glMatrixMultTransposedEXT(mode, m);}
void __stdcall _Lazy_glTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param) {if (GLeeInit()) glTextureParameterfEXT(texture, target, pname, param);}
void __stdcall _Lazy_glTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glTextureParameterfvEXT(texture, target, pname, params);}
void __stdcall _Lazy_glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param) {if (GLeeInit()) glTextureParameteriEXT(texture, target, pname, param);}
void __stdcall _Lazy_glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glTextureParameterivEXT(texture, target, pname, params);}
void __stdcall _Lazy_glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTextureImage1DEXT(texture, target, level, internalformat, width, border, format, type, pixels);}
void __stdcall _Lazy_glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTextureImage2DEXT(texture, target, level, internalformat, width, height, border, format, type, pixels);}
void __stdcall _Lazy_glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels);}
void __stdcall _Lazy_glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);}
void __stdcall _Lazy_glCopyTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) {if (GLeeInit()) glCopyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border);}
void __stdcall _Lazy_glCopyTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {if (GLeeInit()) glCopyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border);}
void __stdcall _Lazy_glCopyTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyTextureSubImage1DEXT(texture, target, level, xoffset, x, y, width);}
void __stdcall _Lazy_glCopyTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, x, y, width, height);}
void __stdcall _Lazy_glGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels) {if (GLeeInit()) glGetTextureImageEXT(texture, target, level, format, type, pixels);}
void __stdcall _Lazy_glGetTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetTextureParameterfvEXT(texture, target, pname, params);}
void __stdcall _Lazy_glGetTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetTextureParameterivEXT(texture, target, pname, params);}
void __stdcall _Lazy_glGetTextureLevelParameterfvEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetTextureLevelParameterfvEXT(texture, target, level, pname, params);}
void __stdcall _Lazy_glGetTextureLevelParameterivEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLint * params) {if (GLeeInit()) glGetTextureLevelParameterivEXT(texture, target, level, pname, params);}
void __stdcall _Lazy_glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, pixels);}
void __stdcall _Lazy_glTextureSubImage3DEXT(GLuint texture, 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()) glTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);}
void __stdcall _Lazy_glCopyTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height);}
void __stdcall _Lazy_glMultiTexParameterfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param) {if (GLeeInit()) glMultiTexParameterfEXT(texunit, target, pname, param);}
void __stdcall _Lazy_glMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glMultiTexParameterfvEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glMultiTexParameteriEXT(GLenum texunit, GLenum target, GLenum pname, GLint param) {if (GLeeInit()) glMultiTexParameteriEXT(texunit, target, pname, param);}
void __stdcall _Lazy_glMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glMultiTexParameterivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, format, type, pixels);}
void __stdcall _Lazy_glMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, format, type, pixels);}
void __stdcall _Lazy_glMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, type, pixels);}
void __stdcall _Lazy_glMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels);}
void __stdcall _Lazy_glCopyMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) {if (GLeeInit()) glCopyMultiTexImage1DEXT(texunit, target, level, internalformat, x, y, width, border);}
void __stdcall _Lazy_glCopyMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {if (GLeeInit()) glCopyMultiTexImage2DEXT(texunit, target, level, internalformat, x, y, width, height, border);}
void __stdcall _Lazy_glCopyMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyMultiTexSubImage1DEXT(texunit, target, level, xoffset, x, y, width);}
void __stdcall _Lazy_glCopyMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, x, y, width, height);}
void __stdcall _Lazy_glGetMultiTexImageEXT(GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels) {if (GLeeInit()) glGetMultiTexImageEXT(texunit, target, level, format, type, pixels);}
void __stdcall _Lazy_glGetMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMultiTexParameterfvEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glGetMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetMultiTexParameterivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glGetMultiTexLevelParameterfvEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMultiTexLevelParameterfvEXT(texunit, target, level, pname, params);}
void __stdcall _Lazy_glGetMultiTexLevelParameterivEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLint * params) {if (GLeeInit()) glGetMultiTexLevelParameterivEXT(texunit, target, level, pname, params);}
void __stdcall _Lazy_glMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels);}
void __stdcall _Lazy_glMultiTexSubImage3DEXT(GLenum texunit, 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()) glMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);}
void __stdcall _Lazy_glCopyMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height);}
void __stdcall _Lazy_glBindMultiTextureEXT(GLenum texunit, GLenum target, GLuint texture) {if (GLeeInit()) glBindMultiTextureEXT(texunit, target, texture);}
void __stdcall _Lazy_glEnableClientStateIndexedEXT(GLenum array, GLuint index) {if (GLeeInit()) glEnableClientStateIndexedEXT(array, index);}
void __stdcall _Lazy_glDisableClientStateIndexedEXT(GLenum array, GLuint index) {if (GLeeInit()) glDisableClientStateIndexedEXT(array, index);}
void __stdcall _Lazy_glMultiTexCoordPointerEXT(GLenum texunit, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glMultiTexCoordPointerEXT(texunit, size, type, stride, pointer);}
void __stdcall _Lazy_glMultiTexEnvfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param) {if (GLeeInit()) glMultiTexEnvfEXT(texunit, target, pname, param);}
void __stdcall _Lazy_glMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glMultiTexEnvfvEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glMultiTexEnviEXT(GLenum texunit, GLenum target, GLenum pname, GLint param) {if (GLeeInit()) glMultiTexEnviEXT(texunit, target, pname, param);}
void __stdcall _Lazy_glMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glMultiTexEnvivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glMultiTexGendEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble param) {if (GLeeInit()) glMultiTexGendEXT(texunit, coord, pname, param);}
void __stdcall _Lazy_glMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLdouble * params) {if (GLeeInit()) glMultiTexGendvEXT(texunit, coord, pname, params);}
void __stdcall _Lazy_glMultiTexGenfEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat param) {if (GLeeInit()) glMultiTexGenfEXT(texunit, coord, pname, param);}
void __stdcall _Lazy_glMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLfloat * params) {if (GLeeInit()) glMultiTexGenfvEXT(texunit, coord, pname, params);}
void __stdcall _Lazy_glMultiTexGeniEXT(GLenum texunit, GLenum coord, GLenum pname, GLint param) {if (GLeeInit()) glMultiTexGeniEXT(texunit, coord, pname, param);}
void __stdcall _Lazy_glMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, const GLint * params) {if (GLeeInit()) glMultiTexGenivEXT(texunit, coord, pname, params);}
void __stdcall _Lazy_glGetMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMultiTexEnvfvEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glGetMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetMultiTexEnvivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glGetMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble * params) {if (GLeeInit()) glGetMultiTexGendvEXT(texunit, coord, pname, params);}
void __stdcall _Lazy_glGetMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMultiTexGenfvEXT(texunit, coord, pname, params);}
void __stdcall _Lazy_glGetMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, GLint * params) {if (GLeeInit()) glGetMultiTexGenivEXT(texunit, coord, pname, params);}
void __stdcall _Lazy_glGetFloatIndexedvEXT(GLenum target, GLuint index, GLfloat * data) {if (GLeeInit()) glGetFloatIndexedvEXT(target, index, data);}
void __stdcall _Lazy_glGetDoubleIndexedvEXT(GLenum target, GLuint index, GLdouble * data) {if (GLeeInit()) glGetDoubleIndexedvEXT(target, index, data);}
void __stdcall _Lazy_glGetPointerIndexedvEXT(GLenum target, GLuint index, GLvoid* * data) {if (GLeeInit()) glGetPointerIndexedvEXT(target, index, data);}
void __stdcall _Lazy_glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, bits);}
void __stdcall _Lazy_glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, bits);}
void __stdcall _Lazy_glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, bits);}
void __stdcall _Lazy_glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);}
void __stdcall _Lazy_glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);}
void __stdcall _Lazy_glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, bits);}
void __stdcall _Lazy_glGetCompressedTextureImageEXT(GLuint texture, GLenum target, GLint lod, GLvoid * img) {if (GLeeInit()) glGetCompressedTextureImageEXT(texture, target, lod, img);}
void __stdcall _Lazy_glCompressedMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits);}
void __stdcall _Lazy_glCompressedMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, imageSize, bits);}
void __stdcall _Lazy_glCompressedMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, imageSize, bits);}
void __stdcall _Lazy_glCompressedMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);}
void __stdcall _Lazy_glCompressedMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits);}
void __stdcall _Lazy_glCompressedMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, imageSize, bits);}
void __stdcall _Lazy_glGetCompressedMultiTexImageEXT(GLenum texunit, GLenum target, GLint lod, GLvoid * img) {if (GLeeInit()) glGetCompressedMultiTexImageEXT(texunit, target, lod, img);}
void __stdcall _Lazy_glNamedProgramStringEXT(GLuint program, GLenum target, GLenum format, GLsizei len, const GLvoid * string) {if (GLeeInit()) glNamedProgramStringEXT(program, target, format, len, string);}
void __stdcall _Lazy_glNamedProgramLocalParameter4dEXT(GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glNamedProgramLocalParameter4dEXT(program, target, index, x, y, z, w);}
void __stdcall _Lazy_glNamedProgramLocalParameter4dvEXT(GLuint program, GLenum target, GLuint index, const GLdouble * params) {if (GLeeInit()) glNamedProgramLocalParameter4dvEXT(program, target, index, params);}
void __stdcall _Lazy_glNamedProgramLocalParameter4fEXT(GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glNamedProgramLocalParameter4fEXT(program, target, index, x, y, z, w);}
void __stdcall _Lazy_glNamedProgramLocalParameter4fvEXT(GLuint program, GLenum target, GLuint index, const GLfloat * params) {if (GLeeInit()) glNamedProgramLocalParameter4fvEXT(program, target, index, params);}
void __stdcall _Lazy_glGetNamedProgramLocalParameterdvEXT(GLuint program, GLenum target, GLuint index, GLdouble * params) {if (GLeeInit()) glGetNamedProgramLocalParameterdvEXT(program, target, index, params);}
void __stdcall _Lazy_glGetNamedProgramLocalParameterfvEXT(GLuint program, GLenum target, GLuint index, GLfloat * params) {if (GLeeInit()) glGetNamedProgramLocalParameterfvEXT(program, target, index, params);}
void __stdcall _Lazy_glGetNamedProgramivEXT(GLuint program, GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetNamedProgramivEXT(program, target, pname, params);}
void __stdcall _Lazy_glGetNamedProgramStringEXT(GLuint program, GLenum target, GLenum pname, GLvoid * string) {if (GLeeInit()) glGetNamedProgramStringEXT(program, target, pname, string);}
void __stdcall _Lazy_glNamedProgramLocalParameters4fvEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat * params) {if (GLeeInit()) glNamedProgramLocalParameters4fvEXT(program, target, index, count, params);}
void __stdcall _Lazy_glNamedProgramLocalParameterI4iEXT(GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glNamedProgramLocalParameterI4iEXT(program, target, index, x, y, z, w);}
void __stdcall _Lazy_glNamedProgramLocalParameterI4ivEXT(GLuint program, GLenum target, GLuint index, const GLint * params) {if (GLeeInit()) glNamedProgramLocalParameterI4ivEXT(program, target, index, params);}
void __stdcall _Lazy_glNamedProgramLocalParametersI4ivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLint * params) {if (GLeeInit()) glNamedProgramLocalParametersI4ivEXT(program, target, index, count, params);}
void __stdcall _Lazy_glNamedProgramLocalParameterI4uiEXT(GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {if (GLeeInit()) glNamedProgramLocalParameterI4uiEXT(program, target, index, x, y, z, w);}
void __stdcall _Lazy_glNamedProgramLocalParameterI4uivEXT(GLuint program, GLenum target, GLuint index, const GLuint * params) {if (GLeeInit()) glNamedProgramLocalParameterI4uivEXT(program, target, index, params);}
void __stdcall _Lazy_glNamedProgramLocalParametersI4uivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint * params) {if (GLeeInit()) glNamedProgramLocalParametersI4uivEXT(program, target, index, count, params);}
void __stdcall _Lazy_glGetNamedProgramLocalParameterIivEXT(GLuint program, GLenum target, GLuint index, GLint * params) {if (GLeeInit()) glGetNamedProgramLocalParameterIivEXT(program, target, index, params);}
void __stdcall _Lazy_glGetNamedProgramLocalParameterIuivEXT(GLuint program, GLenum target, GLuint index, GLuint * params) {if (GLeeInit()) glGetNamedProgramLocalParameterIuivEXT(program, target, index, params);}
void __stdcall _Lazy_glTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glTextureParameterIivEXT(texture, target, pname, params);}
void __stdcall _Lazy_glTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, const GLuint * params) {if (GLeeInit()) glTextureParameterIuivEXT(texture, target, pname, params);}
void __stdcall _Lazy_glGetTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetTextureParameterIivEXT(texture, target, pname, params);}
void __stdcall _Lazy_glGetTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, GLuint * params) {if (GLeeInit()) glGetTextureParameterIuivEXT(texture, target, pname, params);}
void __stdcall _Lazy_glMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glMultiTexParameterIivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, const GLuint * params) {if (GLeeInit()) glMultiTexParameterIuivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glGetMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetMultiTexParameterIivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glGetMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, GLuint * params) {if (GLeeInit()) glGetMultiTexParameterIuivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0) {if (GLeeInit()) glProgramUniform1fEXT(program, location, v0);}
void __stdcall _Lazy_glProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1) {if (GLeeInit()) glProgramUniform2fEXT(program, location, v0, v1);}
void __stdcall _Lazy_glProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {if (GLeeInit()) glProgramUniform3fEXT(program, location, v0, v1, v2);}
void __stdcall _Lazy_glProgramUniform4fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {if (GLeeInit()) glProgramUniform4fEXT(program, location, v0, v1, v2, v3);}
void __stdcall _Lazy_glProgramUniform1iEXT(GLuint program, GLint location, GLint v0) {if (GLeeInit()) glProgramUniform1iEXT(program, location, v0);}
void __stdcall _Lazy_glProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1) {if (GLeeInit()) glProgramUniform2iEXT(program, location, v0, v1);}
void __stdcall _Lazy_glProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) {if (GLeeInit()) glProgramUniform3iEXT(program, location, v0, v1, v2);}
void __stdcall _Lazy_glProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {if (GLeeInit()) glProgramUniform4iEXT(program, location, v0, v1, v2, v3);}
void __stdcall _Lazy_glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glProgramUniform1fvEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glProgramUniform2fvEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glProgramUniform3fvEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glProgramUniform4fvEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glProgramUniform1ivEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glProgramUniform2ivEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glProgramUniform3ivEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glProgramUniform4ivEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniformMatrix2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix2fvEXT(program, location, count, transpose, value);}
void __stdcall _Lazy_glProgramUniformMatrix3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix3fvEXT(program, location, count, transpose, value);}
void __stdcall _Lazy_glProgramUniformMatrix4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix4fvEXT(program, location, count, transpose, value);}
void __stdcall _Lazy_glProgramUniformMatrix2x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix2x3fvEXT(program, location, count, transpose, value);}
void __stdcall _Lazy_glProgramUniformMatrix3x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix3x2fvEXT(program, location, count, transpose, value);}