Newer
Older
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112
3113
3114
3115
3116
3117
3118
3119
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138
3139
3140
3141
3142
3143
3144
3145
3146
3147
3148
3149
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180
3181
3182
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452
3453
3454
3455
3456
3457
3458
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483
3484
3485
3486
3487
3488
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524
3525
3526
3527
3528
3529
3530
3531
3532
3533
3534
3535
3536
3537
3538
3539
3540
3541
3542
3543
3544
3545
3546
3547
3548
3549
3550
3551
3552
3553
3554
3555
3556
3557
3558
3559
3560
3561
3562
3563
3564
3565
3566
3567
3568
3569
3570
3571
3572
3573
3574
3575
3576
3577
3578
3579
3580
3581
3582
3583
3584
3585
3586
3587
3588
3589
3590
3591
3592
3593
3594
3595
3596
3597
3598
3599
3600
3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618
3619
3620
3621
3622
3623
3624
3625
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693
3694
3695
3696
3697
3698
3699
3700
3701
3702
3703
3704
3705
3706
3707
3708
3709
3710
3711
3712
3713
3714
3715
3716
3717
3718
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733
3734
3735
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749
3750
3751
3752
3753
3754
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776
3777
3778
3779
3780
3781
3782
3783
3784
3785
3786
3787
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798
3799
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821
3822
3823
3824
3825
3826
3827
3828
3829
3830
3831
3832
3833
3834
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847
3848
3849
3850
3851
3852
3853
3854
3855
3856
3857
3858
3859
3860
3861
3862
3863
3864
3865
3866
3867
3868
3869
3870
3871
3872
3873
3874
3875
3876
3877
3878
3879
3880
3881
3882
3883
3884
3885
3886
3887
3888
3889
3890
3891
3892
3893
3894
3895
3896
3897
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
3930
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940
3941
3942
3943
3944
3945
3946
3947
3948
3949
3950
3951
3952
3953
3954
3955
3956
3957
3958
3959
3960
3961
3962
3963
3964
3965
3966
3967
3968
3969
3970
3971
3972
3973
3974
3975
3976
3977
3978
3979
3980
3981
3982
3983
3984
3985
3986
3987
3988
3989
3990
3991
3992
3993
3994
3995
3996
3997
3998
3999
4000
PFNGLBINORMAL3IVEXTPROC pglBinormal3ivEXT=_Lazy_glBinormal3ivEXT;
PFNGLBINORMAL3SEXTPROC pglBinormal3sEXT=_Lazy_glBinormal3sEXT;
PFNGLBINORMAL3SVEXTPROC pglBinormal3svEXT=_Lazy_glBinormal3svEXT;
PFNGLTANGENTPOINTEREXTPROC pglTangentPointerEXT=_Lazy_glTangentPointerEXT;
PFNGLBINORMALPOINTEREXTPROC pglBinormalPointerEXT=_Lazy_glBinormalPointerEXT;
#endif
/* GL_EXT_texture_env_combine */
#ifdef __GLEE_GL_EXT_texture_env_combine
#endif
/* GL_APPLE_specular_vector */
#ifdef __GLEE_GL_APPLE_specular_vector
#endif
/* GL_APPLE_transform_hint */
#ifdef __GLEE_GL_APPLE_transform_hint
#endif
/* GL_SGIX_fog_scale */
#ifdef __GLEE_GL_SGIX_fog_scale
#endif
/* GL_SUNX_constant_data */
#ifdef __GLEE_GL_SUNX_constant_data
void __stdcall _Lazy_glFinishTextureSUNX(void) {if (GLeeInit()) glFinishTextureSUNX();}
PFNGLFINISHTEXTURESUNXPROC pglFinishTextureSUNX=_Lazy_glFinishTextureSUNX;
#endif
/* GL_SUN_global_alpha */
#ifdef __GLEE_GL_SUN_global_alpha
void __stdcall _Lazy_glGlobalAlphaFactorbSUN(GLbyte factor) {if (GLeeInit()) glGlobalAlphaFactorbSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactorsSUN(GLshort factor) {if (GLeeInit()) glGlobalAlphaFactorsSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactoriSUN(GLint factor) {if (GLeeInit()) glGlobalAlphaFactoriSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactorfSUN(GLfloat factor) {if (GLeeInit()) glGlobalAlphaFactorfSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactordSUN(GLdouble factor) {if (GLeeInit()) glGlobalAlphaFactordSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactorubSUN(GLubyte factor) {if (GLeeInit()) glGlobalAlphaFactorubSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactorusSUN(GLushort factor) {if (GLeeInit()) glGlobalAlphaFactorusSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactoruiSUN(GLuint factor) {if (GLeeInit()) glGlobalAlphaFactoruiSUN(factor);}
PFNGLGLOBALALPHAFACTORBSUNPROC pglGlobalAlphaFactorbSUN=_Lazy_glGlobalAlphaFactorbSUN;
PFNGLGLOBALALPHAFACTORSSUNPROC pglGlobalAlphaFactorsSUN=_Lazy_glGlobalAlphaFactorsSUN;
PFNGLGLOBALALPHAFACTORISUNPROC pglGlobalAlphaFactoriSUN=_Lazy_glGlobalAlphaFactoriSUN;
PFNGLGLOBALALPHAFACTORFSUNPROC pglGlobalAlphaFactorfSUN=_Lazy_glGlobalAlphaFactorfSUN;
PFNGLGLOBALALPHAFACTORDSUNPROC pglGlobalAlphaFactordSUN=_Lazy_glGlobalAlphaFactordSUN;
PFNGLGLOBALALPHAFACTORUBSUNPROC pglGlobalAlphaFactorubSUN=_Lazy_glGlobalAlphaFactorubSUN;
PFNGLGLOBALALPHAFACTORUSSUNPROC pglGlobalAlphaFactorusSUN=_Lazy_glGlobalAlphaFactorusSUN;
PFNGLGLOBALALPHAFACTORUISUNPROC pglGlobalAlphaFactoruiSUN=_Lazy_glGlobalAlphaFactoruiSUN;
#endif
/* GL_SUN_triangle_list */
#ifdef __GLEE_GL_SUN_triangle_list
void __stdcall _Lazy_glReplacementCodeuiSUN(GLuint code) {if (GLeeInit()) glReplacementCodeuiSUN(code);}
void __stdcall _Lazy_glReplacementCodeusSUN(GLushort code) {if (GLeeInit()) glReplacementCodeusSUN(code);}
void __stdcall _Lazy_glReplacementCodeubSUN(GLubyte code) {if (GLeeInit()) glReplacementCodeubSUN(code);}
void __stdcall _Lazy_glReplacementCodeuivSUN(const GLuint * code) {if (GLeeInit()) glReplacementCodeuivSUN(code);}
void __stdcall _Lazy_glReplacementCodeusvSUN(const GLushort * code) {if (GLeeInit()) glReplacementCodeusvSUN(code);}
void __stdcall _Lazy_glReplacementCodeubvSUN(const GLubyte * code) {if (GLeeInit()) glReplacementCodeubvSUN(code);}
void __stdcall _Lazy_glReplacementCodePointerSUN(GLenum type, GLsizei stride, const GLvoid* * pointer) {if (GLeeInit()) glReplacementCodePointerSUN(type, stride, pointer);}
PFNGLREPLACEMENTCODEUISUNPROC pglReplacementCodeuiSUN=_Lazy_glReplacementCodeuiSUN;
PFNGLREPLACEMENTCODEUSSUNPROC pglReplacementCodeusSUN=_Lazy_glReplacementCodeusSUN;
PFNGLREPLACEMENTCODEUBSUNPROC pglReplacementCodeubSUN=_Lazy_glReplacementCodeubSUN;
PFNGLREPLACEMENTCODEUIVSUNPROC pglReplacementCodeuivSUN=_Lazy_glReplacementCodeuivSUN;
PFNGLREPLACEMENTCODEUSVSUNPROC pglReplacementCodeusvSUN=_Lazy_glReplacementCodeusvSUN;
PFNGLREPLACEMENTCODEUBVSUNPROC pglReplacementCodeubvSUN=_Lazy_glReplacementCodeubvSUN;
PFNGLREPLACEMENTCODEPOINTERSUNPROC pglReplacementCodePointerSUN=_Lazy_glReplacementCodePointerSUN;
#endif
/* GL_SUN_vertex */
#ifdef __GLEE_GL_SUN_vertex
void __stdcall _Lazy_glColor4ubVertex2fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y) {if (GLeeInit()) glColor4ubVertex2fSUN(r, g, b, a, x, y);}
void __stdcall _Lazy_glColor4ubVertex2fvSUN(const GLubyte * c, const GLfloat * v) {if (GLeeInit()) glColor4ubVertex2fvSUN(c, v);}
void __stdcall _Lazy_glColor4ubVertex3fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glColor4ubVertex3fSUN(r, g, b, a, x, y, z);}
void __stdcall _Lazy_glColor4ubVertex3fvSUN(const GLubyte * c, const GLfloat * v) {if (GLeeInit()) glColor4ubVertex3fvSUN(c, v);}
void __stdcall _Lazy_glColor3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glColor3fVertex3fSUN(r, g, b, x, y, z);}
void __stdcall _Lazy_glColor3fVertex3fvSUN(const GLfloat * c, const GLfloat * v) {if (GLeeInit()) glColor3fVertex3fvSUN(c, v);}
void __stdcall _Lazy_glNormal3fVertex3fSUN(GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glNormal3fVertex3fSUN(nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glNormal3fVertex3fvSUN(const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glNormal3fVertex3fvSUN(n, v);}
void __stdcall _Lazy_glColor4fNormal3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glColor4fNormal3fVertex3fSUN(r, g, b, a, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glColor4fNormal3fVertex3fvSUN(const GLfloat * c, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glColor4fNormal3fVertex3fvSUN(c, n, v);}
void __stdcall _Lazy_glTexCoord2fVertex3fSUN(GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glTexCoord2fVertex3fSUN(s, t, x, y, z);}
void __stdcall _Lazy_glTexCoord2fVertex3fvSUN(const GLfloat * tc, const GLfloat * v) {if (GLeeInit()) glTexCoord2fVertex3fvSUN(tc, v);}
void __stdcall _Lazy_glTexCoord4fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glTexCoord4fVertex4fSUN(s, t, p, q, x, y, z, w);}
void __stdcall _Lazy_glTexCoord4fVertex4fvSUN(const GLfloat * tc, const GLfloat * v) {if (GLeeInit()) glTexCoord4fVertex4fvSUN(tc, v);}
void __stdcall _Lazy_glTexCoord2fColor4ubVertex3fSUN(GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glTexCoord2fColor4ubVertex3fSUN(s, t, r, g, b, a, x, y, z);}
void __stdcall _Lazy_glTexCoord2fColor4ubVertex3fvSUN(const GLfloat * tc, const GLubyte * c, const GLfloat * v) {if (GLeeInit()) glTexCoord2fColor4ubVertex3fvSUN(tc, c, v);}
void __stdcall _Lazy_glTexCoord2fColor3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glTexCoord2fColor3fVertex3fSUN(s, t, r, g, b, x, y, z);}
void __stdcall _Lazy_glTexCoord2fColor3fVertex3fvSUN(const GLfloat * tc, const GLfloat * c, const GLfloat * v) {if (GLeeInit()) glTexCoord2fColor3fVertex3fvSUN(tc, c, v);}
void __stdcall _Lazy_glTexCoord2fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glTexCoord2fNormal3fVertex3fSUN(s, t, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glTexCoord2fNormal3fVertex3fvSUN(const GLfloat * tc, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glTexCoord2fNormal3fVertex3fvSUN(tc, n, v);}
void __stdcall _Lazy_glTexCoord2fColor4fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glTexCoord2fColor4fNormal3fVertex3fSUN(s, t, r, g, b, a, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glTexCoord2fColor4fNormal3fVertex3fvSUN(const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, n, v);}
void __stdcall _Lazy_glTexCoord4fColor4fNormal3fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glTexCoord4fColor4fNormal3fVertex4fSUN(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w);}
void __stdcall _Lazy_glTexCoord4fColor4fNormal3fVertex4fvSUN(const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, n, v);}
void __stdcall _Lazy_glReplacementCodeuiVertex3fSUN(GLuint rc, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiVertex3fSUN(rc, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiVertex3fvSUN(const GLuint * rc, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiVertex3fvSUN(rc, v);}
void __stdcall _Lazy_glReplacementCodeuiColor4ubVertex3fSUN(GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiColor4ubVertex3fSUN(rc, r, g, b, a, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiColor4ubVertex3fvSUN(const GLuint * rc, const GLubyte * c, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiColor4ubVertex3fvSUN(rc, c, v);}
void __stdcall _Lazy_glReplacementCodeuiColor3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiColor3fVertex3fSUN(rc, r, g, b, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiColor3fVertex3fvSUN(const GLuint * rc, const GLfloat * c, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiColor3fVertex3fvSUN(rc, c, v);}
void __stdcall _Lazy_glReplacementCodeuiNormal3fVertex3fSUN(GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiNormal3fVertex3fSUN(rc, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiNormal3fVertex3fvSUN(rc, n, v);}
void __stdcall _Lazy_glReplacementCodeuiColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc, r, g, b, a, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiColor4fNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * c, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, n, v);}
void __stdcall _Lazy_glReplacementCodeuiTexCoord2fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiTexCoord2fVertex3fSUN(rc, s, t, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiTexCoord2fVertex3fvSUN(const GLuint * rc, const GLfloat * tc, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, tc, v);}
void __stdcall _Lazy_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc, s, t, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * tc, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, n, v);}
void __stdcall _Lazy_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, n, v);}
PFNGLCOLOR4UBVERTEX2FSUNPROC pglColor4ubVertex2fSUN=_Lazy_glColor4ubVertex2fSUN;
PFNGLCOLOR4UBVERTEX2FVSUNPROC pglColor4ubVertex2fvSUN=_Lazy_glColor4ubVertex2fvSUN;
PFNGLCOLOR4UBVERTEX3FSUNPROC pglColor4ubVertex3fSUN=_Lazy_glColor4ubVertex3fSUN;
PFNGLCOLOR4UBVERTEX3FVSUNPROC pglColor4ubVertex3fvSUN=_Lazy_glColor4ubVertex3fvSUN;
PFNGLCOLOR3FVERTEX3FSUNPROC pglColor3fVertex3fSUN=_Lazy_glColor3fVertex3fSUN;
PFNGLCOLOR3FVERTEX3FVSUNPROC pglColor3fVertex3fvSUN=_Lazy_glColor3fVertex3fvSUN;
PFNGLNORMAL3FVERTEX3FSUNPROC pglNormal3fVertex3fSUN=_Lazy_glNormal3fVertex3fSUN;
PFNGLNORMAL3FVERTEX3FVSUNPROC pglNormal3fVertex3fvSUN=_Lazy_glNormal3fVertex3fvSUN;
PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC pglColor4fNormal3fVertex3fSUN=_Lazy_glColor4fNormal3fVertex3fSUN;
PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC pglColor4fNormal3fVertex3fvSUN=_Lazy_glColor4fNormal3fVertex3fvSUN;
PFNGLTEXCOORD2FVERTEX3FSUNPROC pglTexCoord2fVertex3fSUN=_Lazy_glTexCoord2fVertex3fSUN;
PFNGLTEXCOORD2FVERTEX3FVSUNPROC pglTexCoord2fVertex3fvSUN=_Lazy_glTexCoord2fVertex3fvSUN;
PFNGLTEXCOORD4FVERTEX4FSUNPROC pglTexCoord4fVertex4fSUN=_Lazy_glTexCoord4fVertex4fSUN;
PFNGLTEXCOORD4FVERTEX4FVSUNPROC pglTexCoord4fVertex4fvSUN=_Lazy_glTexCoord4fVertex4fvSUN;
PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC pglTexCoord2fColor4ubVertex3fSUN=_Lazy_glTexCoord2fColor4ubVertex3fSUN;
PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC pglTexCoord2fColor4ubVertex3fvSUN=_Lazy_glTexCoord2fColor4ubVertex3fvSUN;
PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC pglTexCoord2fColor3fVertex3fSUN=_Lazy_glTexCoord2fColor3fVertex3fSUN;
PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC pglTexCoord2fColor3fVertex3fvSUN=_Lazy_glTexCoord2fColor3fVertex3fvSUN;
PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC pglTexCoord2fNormal3fVertex3fSUN=_Lazy_glTexCoord2fNormal3fVertex3fSUN;
PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC pglTexCoord2fNormal3fVertex3fvSUN=_Lazy_glTexCoord2fNormal3fVertex3fvSUN;
PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC pglTexCoord2fColor4fNormal3fVertex3fSUN=_Lazy_glTexCoord2fColor4fNormal3fVertex3fSUN;
PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC pglTexCoord2fColor4fNormal3fVertex3fvSUN=_Lazy_glTexCoord2fColor4fNormal3fVertex3fvSUN;
PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC pglTexCoord4fColor4fNormal3fVertex4fSUN=_Lazy_glTexCoord4fColor4fNormal3fVertex4fSUN;
PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC pglTexCoord4fColor4fNormal3fVertex4fvSUN=_Lazy_glTexCoord4fColor4fNormal3fVertex4fvSUN;
PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC pglReplacementCodeuiVertex3fSUN=_Lazy_glReplacementCodeuiVertex3fSUN;
PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC pglReplacementCodeuiVertex3fvSUN=_Lazy_glReplacementCodeuiVertex3fvSUN;
PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC pglReplacementCodeuiColor4ubVertex3fSUN=_Lazy_glReplacementCodeuiColor4ubVertex3fSUN;
PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC pglReplacementCodeuiColor4ubVertex3fvSUN=_Lazy_glReplacementCodeuiColor4ubVertex3fvSUN;
PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC pglReplacementCodeuiColor3fVertex3fSUN=_Lazy_glReplacementCodeuiColor3fVertex3fSUN;
PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC pglReplacementCodeuiColor3fVertex3fvSUN=_Lazy_glReplacementCodeuiColor3fVertex3fvSUN;
PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC pglReplacementCodeuiNormal3fVertex3fSUN=_Lazy_glReplacementCodeuiNormal3fVertex3fSUN;
PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC pglReplacementCodeuiNormal3fVertex3fvSUN=_Lazy_glReplacementCodeuiNormal3fVertex3fvSUN;
PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC pglReplacementCodeuiColor4fNormal3fVertex3fSUN=_Lazy_glReplacementCodeuiColor4fNormal3fVertex3fSUN;
PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC pglReplacementCodeuiColor4fNormal3fVertex3fvSUN=_Lazy_glReplacementCodeuiColor4fNormal3fVertex3fvSUN;
PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC pglReplacementCodeuiTexCoord2fVertex3fSUN=_Lazy_glReplacementCodeuiTexCoord2fVertex3fSUN;
PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC pglReplacementCodeuiTexCoord2fVertex3fvSUN=_Lazy_glReplacementCodeuiTexCoord2fVertex3fvSUN;
PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC pglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN=_Lazy_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN;
PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC pglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN=_Lazy_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN;
PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC pglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN=_Lazy_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN;
PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC pglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN=_Lazy_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN;
#endif
/* GL_EXT_blend_func_separate */
#ifdef __GLEE_GL_EXT_blend_func_separate
void __stdcall _Lazy_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {if (GLeeInit()) glBlendFuncSeparateEXT(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);}
PFNGLBLENDFUNCSEPARATEEXTPROC pglBlendFuncSeparateEXT=_Lazy_glBlendFuncSeparateEXT;
#endif
/* GL_INGR_color_clamp */
#ifdef __GLEE_GL_INGR_color_clamp
#endif
/* GL_INGR_interlace_read */
#ifdef __GLEE_GL_INGR_interlace_read
#endif
/* GL_EXT_stencil_wrap */
#ifdef __GLEE_GL_EXT_stencil_wrap
#endif
/* GL_EXT_422_pixels */
#ifdef __GLEE_GL_EXT_422_pixels
#endif
/* GL_NV_texgen_reflection */
#ifdef __GLEE_GL_NV_texgen_reflection
#endif
/* GL_EXT_texture_cube_map */
#ifdef __GLEE_GL_EXT_texture_cube_map
#endif
/* GL_SUN_convolution_border_modes */
#ifdef __GLEE_GL_SUN_convolution_border_modes
#endif
/* GL_EXT_texture_env_add */
#ifdef __GLEE_GL_EXT_texture_env_add
#endif
/* GL_EXT_texture_lod_bias */
#ifdef __GLEE_GL_EXT_texture_lod_bias
#endif
/* GL_EXT_texture_filter_anisotropic */
#ifdef __GLEE_GL_EXT_texture_filter_anisotropic
#endif
/* GL_EXT_vertex_weighting */
#ifdef __GLEE_GL_EXT_vertex_weighting
void __stdcall _Lazy_glVertexWeightfEXT(GLfloat weight) {if (GLeeInit()) glVertexWeightfEXT(weight);}
void __stdcall _Lazy_glVertexWeightfvEXT(const GLfloat * weight) {if (GLeeInit()) glVertexWeightfvEXT(weight);}
void __stdcall _Lazy_glVertexWeightPointerEXT(GLsizei size, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glVertexWeightPointerEXT(size, type, stride, pointer);}
PFNGLVERTEXWEIGHTFEXTPROC pglVertexWeightfEXT=_Lazy_glVertexWeightfEXT;
PFNGLVERTEXWEIGHTFVEXTPROC pglVertexWeightfvEXT=_Lazy_glVertexWeightfvEXT;
PFNGLVERTEXWEIGHTPOINTEREXTPROC pglVertexWeightPointerEXT=_Lazy_glVertexWeightPointerEXT;
#endif
/* GL_NV_light_max_exponent */
#ifdef __GLEE_GL_NV_light_max_exponent
#endif
/* GL_NV_vertex_array_range */
#ifdef __GLEE_GL_NV_vertex_array_range
void __stdcall _Lazy_glFlushVertexArrayRangeNV(void) {if (GLeeInit()) glFlushVertexArrayRangeNV();}
void __stdcall _Lazy_glVertexArrayRangeNV(GLsizei length, const GLvoid * pointer) {if (GLeeInit()) glVertexArrayRangeNV(length, pointer);}
PFNGLFLUSHVERTEXARRAYRANGENVPROC pglFlushVertexArrayRangeNV=_Lazy_glFlushVertexArrayRangeNV;
PFNGLVERTEXARRAYRANGENVPROC pglVertexArrayRangeNV=_Lazy_glVertexArrayRangeNV;
#endif
/* GL_NV_register_combiners */
#ifdef __GLEE_GL_NV_register_combiners
void __stdcall _Lazy_glCombinerParameterfvNV(GLenum pname, const GLfloat * params) {if (GLeeInit()) glCombinerParameterfvNV(pname, params);}
void __stdcall _Lazy_glCombinerParameterfNV(GLenum pname, GLfloat param) {if (GLeeInit()) glCombinerParameterfNV(pname, param);}
void __stdcall _Lazy_glCombinerParameterivNV(GLenum pname, const GLint * params) {if (GLeeInit()) glCombinerParameterivNV(pname, params);}
void __stdcall _Lazy_glCombinerParameteriNV(GLenum pname, GLint param) {if (GLeeInit()) glCombinerParameteriNV(pname, param);}
void __stdcall _Lazy_glCombinerInputNV(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage) {if (GLeeInit()) glCombinerInputNV(stage, portion, variable, input, mapping, componentUsage);}
void __stdcall _Lazy_glCombinerOutputNV(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum) {if (GLeeInit()) glCombinerOutputNV(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum);}
void __stdcall _Lazy_glFinalCombinerInputNV(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage) {if (GLeeInit()) glFinalCombinerInputNV(variable, input, mapping, componentUsage);}
void __stdcall _Lazy_glGetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetCombinerInputParameterfvNV(stage, portion, variable, pname, params);}
void __stdcall _Lazy_glGetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params) {if (GLeeInit()) glGetCombinerInputParameterivNV(stage, portion, variable, pname, params);}
void __stdcall _Lazy_glGetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetCombinerOutputParameterfvNV(stage, portion, pname, params);}
void __stdcall _Lazy_glGetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint * params) {if (GLeeInit()) glGetCombinerOutputParameterivNV(stage, portion, pname, params);}
void __stdcall _Lazy_glGetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetFinalCombinerInputParameterfvNV(variable, pname, params);}
void __stdcall _Lazy_glGetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, GLint * params) {if (GLeeInit()) glGetFinalCombinerInputParameterivNV(variable, pname, params);}
PFNGLCOMBINERPARAMETERFVNVPROC pglCombinerParameterfvNV=_Lazy_glCombinerParameterfvNV;
PFNGLCOMBINERPARAMETERFNVPROC pglCombinerParameterfNV=_Lazy_glCombinerParameterfNV;
PFNGLCOMBINERPARAMETERIVNVPROC pglCombinerParameterivNV=_Lazy_glCombinerParameterivNV;
PFNGLCOMBINERPARAMETERINVPROC pglCombinerParameteriNV=_Lazy_glCombinerParameteriNV;
PFNGLCOMBINERINPUTNVPROC pglCombinerInputNV=_Lazy_glCombinerInputNV;
PFNGLCOMBINEROUTPUTNVPROC pglCombinerOutputNV=_Lazy_glCombinerOutputNV;
PFNGLFINALCOMBINERINPUTNVPROC pglFinalCombinerInputNV=_Lazy_glFinalCombinerInputNV;
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC pglGetCombinerInputParameterfvNV=_Lazy_glGetCombinerInputParameterfvNV;
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC pglGetCombinerInputParameterivNV=_Lazy_glGetCombinerInputParameterivNV;
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC pglGetCombinerOutputParameterfvNV=_Lazy_glGetCombinerOutputParameterfvNV;
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC pglGetCombinerOutputParameterivNV=_Lazy_glGetCombinerOutputParameterivNV;
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC pglGetFinalCombinerInputParameterfvNV=_Lazy_glGetFinalCombinerInputParameterfvNV;
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC pglGetFinalCombinerInputParameterivNV=_Lazy_glGetFinalCombinerInputParameterivNV;
#endif
/* GL_NV_fog_distance */
#ifdef __GLEE_GL_NV_fog_distance
#endif
/* GL_NV_texgen_emboss */
#ifdef __GLEE_GL_NV_texgen_emboss
#endif
/* GL_NV_blend_square */
#ifdef __GLEE_GL_NV_blend_square
#endif
/* GL_NV_texture_env_combine4 */
#ifdef __GLEE_GL_NV_texture_env_combine4
#endif
/* GL_MESA_resize_buffers */
#ifdef __GLEE_GL_MESA_resize_buffers
void __stdcall _Lazy_glResizeBuffersMESA(void) {if (GLeeInit()) glResizeBuffersMESA();}
PFNGLRESIZEBUFFERSMESAPROC pglResizeBuffersMESA=_Lazy_glResizeBuffersMESA;
#endif
/* GL_MESA_window_pos */
#ifdef __GLEE_GL_MESA_window_pos
void __stdcall _Lazy_glWindowPos2dMESA(GLdouble x, GLdouble y) {if (GLeeInit()) glWindowPos2dMESA(x, y);}
void __stdcall _Lazy_glWindowPos2dvMESA(const GLdouble * v) {if (GLeeInit()) glWindowPos2dvMESA(v);}
void __stdcall _Lazy_glWindowPos2fMESA(GLfloat x, GLfloat y) {if (GLeeInit()) glWindowPos2fMESA(x, y);}
void __stdcall _Lazy_glWindowPos2fvMESA(const GLfloat * v) {if (GLeeInit()) glWindowPos2fvMESA(v);}
void __stdcall _Lazy_glWindowPos2iMESA(GLint x, GLint y) {if (GLeeInit()) glWindowPos2iMESA(x, y);}
void __stdcall _Lazy_glWindowPos2ivMESA(const GLint * v) {if (GLeeInit()) glWindowPos2ivMESA(v);}
void __stdcall _Lazy_glWindowPos2sMESA(GLshort x, GLshort y) {if (GLeeInit()) glWindowPos2sMESA(x, y);}
void __stdcall _Lazy_glWindowPos2svMESA(const GLshort * v) {if (GLeeInit()) glWindowPos2svMESA(v);}
void __stdcall _Lazy_glWindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glWindowPos3dMESA(x, y, z);}
void __stdcall _Lazy_glWindowPos3dvMESA(const GLdouble * v) {if (GLeeInit()) glWindowPos3dvMESA(v);}
void __stdcall _Lazy_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glWindowPos3fMESA(x, y, z);}
void __stdcall _Lazy_glWindowPos3fvMESA(const GLfloat * v) {if (GLeeInit()) glWindowPos3fvMESA(v);}
void __stdcall _Lazy_glWindowPos3iMESA(GLint x, GLint y, GLint z) {if (GLeeInit()) glWindowPos3iMESA(x, y, z);}
void __stdcall _Lazy_glWindowPos3ivMESA(const GLint * v) {if (GLeeInit()) glWindowPos3ivMESA(v);}
void __stdcall _Lazy_glWindowPos3sMESA(GLshort x, GLshort y, GLshort z) {if (GLeeInit()) glWindowPos3sMESA(x, y, z);}
void __stdcall _Lazy_glWindowPos3svMESA(const GLshort * v) {if (GLeeInit()) glWindowPos3svMESA(v);}
void __stdcall _Lazy_glWindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glWindowPos4dMESA(x, y, z, w);}
void __stdcall _Lazy_glWindowPos4dvMESA(const GLdouble * v) {if (GLeeInit()) glWindowPos4dvMESA(v);}
void __stdcall _Lazy_glWindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glWindowPos4fMESA(x, y, z, w);}
void __stdcall _Lazy_glWindowPos4fvMESA(const GLfloat * v) {if (GLeeInit()) glWindowPos4fvMESA(v);}
void __stdcall _Lazy_glWindowPos4iMESA(GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glWindowPos4iMESA(x, y, z, w);}
void __stdcall _Lazy_glWindowPos4ivMESA(const GLint * v) {if (GLeeInit()) glWindowPos4ivMESA(v);}
void __stdcall _Lazy_glWindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w) {if (GLeeInit()) glWindowPos4sMESA(x, y, z, w);}
void __stdcall _Lazy_glWindowPos4svMESA(const GLshort * v) {if (GLeeInit()) glWindowPos4svMESA(v);}
PFNGLWINDOWPOS2DMESAPROC pglWindowPos2dMESA=_Lazy_glWindowPos2dMESA;
PFNGLWINDOWPOS2DVMESAPROC pglWindowPos2dvMESA=_Lazy_glWindowPos2dvMESA;
PFNGLWINDOWPOS2FMESAPROC pglWindowPos2fMESA=_Lazy_glWindowPos2fMESA;
PFNGLWINDOWPOS2FVMESAPROC pglWindowPos2fvMESA=_Lazy_glWindowPos2fvMESA;
PFNGLWINDOWPOS2IMESAPROC pglWindowPos2iMESA=_Lazy_glWindowPos2iMESA;
PFNGLWINDOWPOS2IVMESAPROC pglWindowPos2ivMESA=_Lazy_glWindowPos2ivMESA;
PFNGLWINDOWPOS2SMESAPROC pglWindowPos2sMESA=_Lazy_glWindowPos2sMESA;
PFNGLWINDOWPOS2SVMESAPROC pglWindowPos2svMESA=_Lazy_glWindowPos2svMESA;
PFNGLWINDOWPOS3DMESAPROC pglWindowPos3dMESA=_Lazy_glWindowPos3dMESA;
PFNGLWINDOWPOS3DVMESAPROC pglWindowPos3dvMESA=_Lazy_glWindowPos3dvMESA;
PFNGLWINDOWPOS3FMESAPROC pglWindowPos3fMESA=_Lazy_glWindowPos3fMESA;
PFNGLWINDOWPOS3FVMESAPROC pglWindowPos3fvMESA=_Lazy_glWindowPos3fvMESA;
PFNGLWINDOWPOS3IMESAPROC pglWindowPos3iMESA=_Lazy_glWindowPos3iMESA;
PFNGLWINDOWPOS3IVMESAPROC pglWindowPos3ivMESA=_Lazy_glWindowPos3ivMESA;
PFNGLWINDOWPOS3SMESAPROC pglWindowPos3sMESA=_Lazy_glWindowPos3sMESA;
PFNGLWINDOWPOS3SVMESAPROC pglWindowPos3svMESA=_Lazy_glWindowPos3svMESA;
PFNGLWINDOWPOS4DMESAPROC pglWindowPos4dMESA=_Lazy_glWindowPos4dMESA;
PFNGLWINDOWPOS4DVMESAPROC pglWindowPos4dvMESA=_Lazy_glWindowPos4dvMESA;
PFNGLWINDOWPOS4FMESAPROC pglWindowPos4fMESA=_Lazy_glWindowPos4fMESA;
PFNGLWINDOWPOS4FVMESAPROC pglWindowPos4fvMESA=_Lazy_glWindowPos4fvMESA;
PFNGLWINDOWPOS4IMESAPROC pglWindowPos4iMESA=_Lazy_glWindowPos4iMESA;
PFNGLWINDOWPOS4IVMESAPROC pglWindowPos4ivMESA=_Lazy_glWindowPos4ivMESA;
PFNGLWINDOWPOS4SMESAPROC pglWindowPos4sMESA=_Lazy_glWindowPos4sMESA;
PFNGLWINDOWPOS4SVMESAPROC pglWindowPos4svMESA=_Lazy_glWindowPos4svMESA;
#endif
/* GL_EXT_texture_compression_s3tc */
#ifdef __GLEE_GL_EXT_texture_compression_s3tc
#endif
/* GL_IBM_cull_vertex */
#ifdef __GLEE_GL_IBM_cull_vertex
#endif
/* GL_IBM_multimode_draw_arrays */
#ifdef __GLEE_GL_IBM_multimode_draw_arrays
void __stdcall _Lazy_glMultiModeDrawArraysIBM(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride) {if (GLeeInit()) glMultiModeDrawArraysIBM(mode, first, count, primcount, modestride);}
void __stdcall _Lazy_glMultiModeDrawElementsIBM(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid* const * indices, GLsizei primcount, GLint modestride) {if (GLeeInit()) glMultiModeDrawElementsIBM(mode, count, type, indices, primcount, modestride);}
PFNGLMULTIMODEDRAWARRAYSIBMPROC pglMultiModeDrawArraysIBM=_Lazy_glMultiModeDrawArraysIBM;
PFNGLMULTIMODEDRAWELEMENTSIBMPROC pglMultiModeDrawElementsIBM=_Lazy_glMultiModeDrawElementsIBM;
#endif
/* GL_IBM_vertex_array_lists */
#ifdef __GLEE_GL_IBM_vertex_array_lists
void __stdcall _Lazy_glColorPointerListIBM(GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glColorPointerListIBM(size, type, stride, pointer, ptrstride);}
void __stdcall _Lazy_glSecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glSecondaryColorPointerListIBM(size, type, stride, pointer, ptrstride);}
void __stdcall _Lazy_glEdgeFlagPointerListIBM(GLint stride, const GLboolean* * pointer, GLint ptrstride) {if (GLeeInit()) glEdgeFlagPointerListIBM(stride, pointer, ptrstride);}
void __stdcall _Lazy_glFogCoordPointerListIBM(GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glFogCoordPointerListIBM(type, stride, pointer, ptrstride);}
void __stdcall _Lazy_glIndexPointerListIBM(GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glIndexPointerListIBM(type, stride, pointer, ptrstride);}
void __stdcall _Lazy_glNormalPointerListIBM(GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glNormalPointerListIBM(type, stride, pointer, ptrstride);}
void __stdcall _Lazy_glTexCoordPointerListIBM(GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glTexCoordPointerListIBM(size, type, stride, pointer, ptrstride);}
void __stdcall _Lazy_glVertexPointerListIBM(GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glVertexPointerListIBM(size, type, stride, pointer, ptrstride);}
PFNGLCOLORPOINTERLISTIBMPROC pglColorPointerListIBM=_Lazy_glColorPointerListIBM;
PFNGLSECONDARYCOLORPOINTERLISTIBMPROC pglSecondaryColorPointerListIBM=_Lazy_glSecondaryColorPointerListIBM;
PFNGLEDGEFLAGPOINTERLISTIBMPROC pglEdgeFlagPointerListIBM=_Lazy_glEdgeFlagPointerListIBM;
PFNGLFOGCOORDPOINTERLISTIBMPROC pglFogCoordPointerListIBM=_Lazy_glFogCoordPointerListIBM;
PFNGLINDEXPOINTERLISTIBMPROC pglIndexPointerListIBM=_Lazy_glIndexPointerListIBM;
PFNGLNORMALPOINTERLISTIBMPROC pglNormalPointerListIBM=_Lazy_glNormalPointerListIBM;
PFNGLTEXCOORDPOINTERLISTIBMPROC pglTexCoordPointerListIBM=_Lazy_glTexCoordPointerListIBM;
PFNGLVERTEXPOINTERLISTIBMPROC pglVertexPointerListIBM=_Lazy_glVertexPointerListIBM;
#endif
/* GL_SGIX_subsample */
#ifdef __GLEE_GL_SGIX_subsample
#endif
/* GL_SGIX_ycrcb_subsample */
#ifdef __GLEE_GL_SGIX_ycrcb_subsample
#endif
/* GL_SGIX_ycrcba */
#ifdef __GLEE_GL_SGIX_ycrcba
#endif
/* GL_SGI_depth_pass_instrument */
#ifdef __GLEE_GL_SGI_depth_pass_instrument
#endif
/* GL_3DFX_texture_compression_FXT1 */
#ifdef __GLEE_GL_3DFX_texture_compression_FXT1
#endif
/* GL_3DFX_multisample */
#ifdef __GLEE_GL_3DFX_multisample
#endif
/* GL_3DFX_tbuffer */
#ifdef __GLEE_GL_3DFX_tbuffer
void __stdcall _Lazy_glTbufferMask3DFX(GLuint mask) {if (GLeeInit()) glTbufferMask3DFX(mask);}
PFNGLTBUFFERMASK3DFXPROC pglTbufferMask3DFX=_Lazy_glTbufferMask3DFX;
#endif
/* GL_EXT_multisample */
#ifdef __GLEE_GL_EXT_multisample
void __stdcall _Lazy_glSampleMaskEXT(GLclampf value, GLboolean invert) {if (GLeeInit()) glSampleMaskEXT(value, invert);}
void __stdcall _Lazy_glSamplePatternEXT(GLenum pattern) {if (GLeeInit()) glSamplePatternEXT(pattern);}
PFNGLSAMPLEMASKEXTPROC pglSampleMaskEXT=_Lazy_glSampleMaskEXT;
PFNGLSAMPLEPATTERNEXTPROC pglSamplePatternEXT=_Lazy_glSamplePatternEXT;
#endif
/* GL_SGIX_vertex_preclip */
#ifdef __GLEE_GL_SGIX_vertex_preclip
#endif
/* GL_SGIX_convolution_accuracy */
#ifdef __GLEE_GL_SGIX_convolution_accuracy
#endif
/* GL_SGIX_resample */
#ifdef __GLEE_GL_SGIX_resample
#endif
/* GL_SGIS_point_line_texgen */
#ifdef __GLEE_GL_SGIS_point_line_texgen
#endif
/* GL_SGIS_texture_color_mask */
#ifdef __GLEE_GL_SGIS_texture_color_mask
void __stdcall _Lazy_glTextureColorMaskSGIS(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {if (GLeeInit()) glTextureColorMaskSGIS(red, green, blue, alpha);}
PFNGLTEXTURECOLORMASKSGISPROC pglTextureColorMaskSGIS=_Lazy_glTextureColorMaskSGIS;
#endif
/* GL_EXT_texture_env_dot3 */
#ifdef __GLEE_GL_EXT_texture_env_dot3
#endif
/* GL_ATI_texture_mirror_once */
#ifdef __GLEE_GL_ATI_texture_mirror_once
#endif
/* GL_NV_fence */
#ifdef __GLEE_GL_NV_fence
void __stdcall _Lazy_glDeleteFencesNV(GLsizei n, const GLuint * fences) {if (GLeeInit()) glDeleteFencesNV(n, fences);}
void __stdcall _Lazy_glGenFencesNV(GLsizei n, GLuint * fences) {if (GLeeInit()) glGenFencesNV(n, fences);}
GLboolean __stdcall _Lazy_glIsFenceNV(GLuint fence) {if (GLeeInit()) return glIsFenceNV(fence); return (GLboolean)0;}
GLboolean __stdcall _Lazy_glTestFenceNV(GLuint fence) {if (GLeeInit()) return glTestFenceNV(fence); return (GLboolean)0;}
void __stdcall _Lazy_glGetFenceivNV(GLuint fence, GLenum pname, GLint * params) {if (GLeeInit()) glGetFenceivNV(fence, pname, params);}
void __stdcall _Lazy_glFinishFenceNV(GLuint fence) {if (GLeeInit()) glFinishFenceNV(fence);}
void __stdcall _Lazy_glSetFenceNV(GLuint fence, GLenum condition) {if (GLeeInit()) glSetFenceNV(fence, condition);}
PFNGLDELETEFENCESNVPROC pglDeleteFencesNV=_Lazy_glDeleteFencesNV;
PFNGLGENFENCESNVPROC pglGenFencesNV=_Lazy_glGenFencesNV;
PFNGLISFENCENVPROC pglIsFenceNV=_Lazy_glIsFenceNV;
PFNGLTESTFENCENVPROC pglTestFenceNV=_Lazy_glTestFenceNV;
PFNGLGETFENCEIVNVPROC pglGetFenceivNV=_Lazy_glGetFenceivNV;
PFNGLFINISHFENCENVPROC pglFinishFenceNV=_Lazy_glFinishFenceNV;
PFNGLSETFENCENVPROC pglSetFenceNV=_Lazy_glSetFenceNV;
#endif
/* GL_IBM_texture_mirrored_repeat */
#ifdef __GLEE_GL_IBM_texture_mirrored_repeat
#endif
/* GL_NV_evaluators */
#ifdef __GLEE_GL_NV_evaluators
void __stdcall _Lazy_glMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid * points) {if (GLeeInit()) glMapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, points);}
void __stdcall _Lazy_glMapParameterivNV(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glMapParameterivNV(target, pname, params);}
void __stdcall _Lazy_glMapParameterfvNV(GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glMapParameterfvNV(target, pname, params);}
void __stdcall _Lazy_glGetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid * points) {if (GLeeInit()) glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, points);}
void __stdcall _Lazy_glGetMapParameterivNV(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetMapParameterivNV(target, pname, params);}
void __stdcall _Lazy_glGetMapParameterfvNV(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMapParameterfvNV(target, pname, params);}
void __stdcall _Lazy_glGetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, GLint * params) {if (GLeeInit()) glGetMapAttribParameterivNV(target, index, pname, params);}
void __stdcall _Lazy_glGetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMapAttribParameterfvNV(target, index, pname, params);}
void __stdcall _Lazy_glEvalMapsNV(GLenum target, GLenum mode) {if (GLeeInit()) glEvalMapsNV(target, mode);}
PFNGLMAPCONTROLPOINTSNVPROC pglMapControlPointsNV=_Lazy_glMapControlPointsNV;
PFNGLMAPPARAMETERIVNVPROC pglMapParameterivNV=_Lazy_glMapParameterivNV;
PFNGLMAPPARAMETERFVNVPROC pglMapParameterfvNV=_Lazy_glMapParameterfvNV;
PFNGLGETMAPCONTROLPOINTSNVPROC pglGetMapControlPointsNV=_Lazy_glGetMapControlPointsNV;
PFNGLGETMAPPARAMETERIVNVPROC pglGetMapParameterivNV=_Lazy_glGetMapParameterivNV;
PFNGLGETMAPPARAMETERFVNVPROC pglGetMapParameterfvNV=_Lazy_glGetMapParameterfvNV;
PFNGLGETMAPATTRIBPARAMETERIVNVPROC pglGetMapAttribParameterivNV=_Lazy_glGetMapAttribParameterivNV;
PFNGLGETMAPATTRIBPARAMETERFVNVPROC pglGetMapAttribParameterfvNV=_Lazy_glGetMapAttribParameterfvNV;
PFNGLEVALMAPSNVPROC pglEvalMapsNV=_Lazy_glEvalMapsNV;
#endif
/* GL_NV_packed_depth_stencil */
#ifdef __GLEE_GL_NV_packed_depth_stencil
#endif
/* GL_NV_register_combiners2 */
#ifdef __GLEE_GL_NV_register_combiners2
void __stdcall _Lazy_glCombinerStageParameterfvNV(GLenum stage, GLenum pname, const GLfloat * params) {if (GLeeInit()) glCombinerStageParameterfvNV(stage, pname, params);}
void __stdcall _Lazy_glGetCombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetCombinerStageParameterfvNV(stage, pname, params);}
PFNGLCOMBINERSTAGEPARAMETERFVNVPROC pglCombinerStageParameterfvNV=_Lazy_glCombinerStageParameterfvNV;
PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC pglGetCombinerStageParameterfvNV=_Lazy_glGetCombinerStageParameterfvNV;
#endif
/* GL_NV_texture_compression_vtc */
#ifdef __GLEE_GL_NV_texture_compression_vtc
#endif
/* GL_NV_texture_rectangle */
#ifdef __GLEE_GL_NV_texture_rectangle
#endif
/* GL_NV_texture_shader */
#ifdef __GLEE_GL_NV_texture_shader
#endif
/* GL_NV_texture_shader2 */
#ifdef __GLEE_GL_NV_texture_shader2
#endif
/* GL_NV_vertex_array_range2 */
#ifdef __GLEE_GL_NV_vertex_array_range2
#endif
/* GL_NV_vertex_program */
#ifdef __GLEE_GL_NV_vertex_program
GLboolean __stdcall _Lazy_glAreProgramsResidentNV(GLsizei n, const GLuint * programs, GLboolean * residences) {if (GLeeInit()) return glAreProgramsResidentNV(n, programs, residences); return (GLboolean)0;}
void __stdcall _Lazy_glBindProgramNV(GLenum target, GLuint id) {if (GLeeInit()) glBindProgramNV(target, id);}
void __stdcall _Lazy_glDeleteProgramsNV(GLsizei n, const GLuint * programs) {if (GLeeInit()) glDeleteProgramsNV(n, programs);}
void __stdcall _Lazy_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params) {if (GLeeInit()) glExecuteProgramNV(target, id, params);}
void __stdcall _Lazy_glGenProgramsNV(GLsizei n, GLuint * programs) {if (GLeeInit()) glGenProgramsNV(n, programs);}
void __stdcall _Lazy_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params) {if (GLeeInit()) glGetProgramParameterdvNV(target, index, pname, params);}
void __stdcall _Lazy_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetProgramParameterfvNV(target, index, pname, params);}
void __stdcall _Lazy_glGetProgramivNV(GLuint id, GLenum pname, GLint * params) {if (GLeeInit()) glGetProgramivNV(id, pname, params);}
void __stdcall _Lazy_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program) {if (GLeeInit()) glGetProgramStringNV(id, pname, program);}
void __stdcall _Lazy_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params) {if (GLeeInit()) glGetTrackMatrixivNV(target, address, pname, params);}
void __stdcall _Lazy_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params) {if (GLeeInit()) glGetVertexAttribdvNV(index, pname, params);}
void __stdcall _Lazy_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetVertexAttribfvNV(index, pname, params);}
void __stdcall _Lazy_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params) {if (GLeeInit()) glGetVertexAttribivNV(index, pname, params);}
void __stdcall _Lazy_glGetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid* * pointer) {if (GLeeInit()) glGetVertexAttribPointervNV(index, pname, pointer);}
GLboolean __stdcall _Lazy_glIsProgramNV(GLuint id) {if (GLeeInit()) return glIsProgramNV(id); return (GLboolean)0;}
void __stdcall _Lazy_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program) {if (GLeeInit()) glLoadProgramNV(target, id, len, program);}
void __stdcall _Lazy_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glProgramParameter4dNV(target, index, x, y, z, w);}
void __stdcall _Lazy_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * v) {if (GLeeInit()) glProgramParameter4dvNV(target, index, v);}
void __stdcall _Lazy_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glProgramParameter4fNV(target, index, x, y, z, w);}
void __stdcall _Lazy_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * v) {if (GLeeInit()) glProgramParameter4fvNV(target, index, v);}
void __stdcall _Lazy_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, const GLdouble * v) {if (GLeeInit()) glProgramParameters4dvNV(target, index, count, v);}
void __stdcall _Lazy_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, const GLfloat * v) {if (GLeeInit()) glProgramParameters4fvNV(target, index, count, v);}
void __stdcall _Lazy_glRequestResidentProgramsNV(GLsizei n, const GLuint * programs) {if (GLeeInit()) glRequestResidentProgramsNV(n, programs);}
void __stdcall _Lazy_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform) {if (GLeeInit()) glTrackMatrixNV(target, address, matrix, transform);}
void __stdcall _Lazy_glVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glVertexAttribPointerNV(index, fsize, type, stride, pointer);}
void __stdcall _Lazy_glVertexAttrib1dNV(GLuint index, GLdouble x) {if (GLeeInit()) glVertexAttrib1dNV(index, x);}
void __stdcall _Lazy_glVertexAttrib1dvNV(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib1dvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib1fNV(GLuint index, GLfloat x) {if (GLeeInit()) glVertexAttrib1fNV(index, x);}
void __stdcall _Lazy_glVertexAttrib1fvNV(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib1fvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib1sNV(GLuint index, GLshort x) {if (GLeeInit()) glVertexAttrib1sNV(index, x);}
void __stdcall _Lazy_glVertexAttrib1svNV(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib1svNV(index, v);}
void __stdcall _Lazy_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y) {if (GLeeInit()) glVertexAttrib2dNV(index, x, y);}
void __stdcall _Lazy_glVertexAttrib2dvNV(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib2dvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y) {if (GLeeInit()) glVertexAttrib2fNV(index, x, y);}
void __stdcall _Lazy_glVertexAttrib2fvNV(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib2fvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y) {if (GLeeInit()) glVertexAttrib2sNV(index, x, y);}
void __stdcall _Lazy_glVertexAttrib2svNV(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib2svNV(index, v);}
void __stdcall _Lazy_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glVertexAttrib3dNV(index, x, y, z);}
void __stdcall _Lazy_glVertexAttrib3dvNV(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib3dvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glVertexAttrib3fNV(index, x, y, z);}
void __stdcall _Lazy_glVertexAttrib3fvNV(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib3fvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z) {if (GLeeInit()) glVertexAttrib3sNV(index, x, y, z);}
void __stdcall _Lazy_glVertexAttrib3svNV(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib3svNV(index, v);}
void __stdcall _Lazy_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glVertexAttrib4dNV(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttrib4dvNV(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib4dvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glVertexAttrib4fNV(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttrib4fvNV(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib4fvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {if (GLeeInit()) glVertexAttrib4sNV(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttrib4svNV(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib4svNV(index, v);}
void __stdcall _Lazy_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {if (GLeeInit()) glVertexAttrib4ubNV(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v) {if (GLeeInit()) glVertexAttrib4ubvNV(index, v);}
void __stdcall _Lazy_glVertexAttribs1dvNV(GLuint index, GLsizei count, const GLdouble * v) {if (GLeeInit()) glVertexAttribs1dvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs1fvNV(GLuint index, GLsizei count, const GLfloat * v) {if (GLeeInit()) glVertexAttribs1fvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs1svNV(GLuint index, GLsizei count, const GLshort * v) {if (GLeeInit()) glVertexAttribs1svNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs2dvNV(GLuint index, GLsizei count, const GLdouble * v) {if (GLeeInit()) glVertexAttribs2dvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs2fvNV(GLuint index, GLsizei count, const GLfloat * v) {if (GLeeInit()) glVertexAttribs2fvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs2svNV(GLuint index, GLsizei count, const GLshort * v) {if (GLeeInit()) glVertexAttribs2svNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs3dvNV(GLuint index, GLsizei count, const GLdouble * v) {if (GLeeInit()) glVertexAttribs3dvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs3fvNV(GLuint index, GLsizei count, const GLfloat * v) {if (GLeeInit()) glVertexAttribs3fvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs3svNV(GLuint index, GLsizei count, const GLshort * v) {if (GLeeInit()) glVertexAttribs3svNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs4dvNV(GLuint index, GLsizei count, const GLdouble * v) {if (GLeeInit()) glVertexAttribs4dvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs4fvNV(GLuint index, GLsizei count, const GLfloat * v) {if (GLeeInit()) glVertexAttribs4fvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs4svNV(GLuint index, GLsizei count, const GLshort * v) {if (GLeeInit()) glVertexAttribs4svNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs4ubvNV(GLuint index, GLsizei count, const GLubyte * v) {if (GLeeInit()) glVertexAttribs4ubvNV(index, count, v);}
PFNGLAREPROGRAMSRESIDENTNVPROC pglAreProgramsResidentNV=_Lazy_glAreProgramsResidentNV;
PFNGLBINDPROGRAMNVPROC pglBindProgramNV=_Lazy_glBindProgramNV;
PFNGLDELETEPROGRAMSNVPROC pglDeleteProgramsNV=_Lazy_glDeleteProgramsNV;
PFNGLEXECUTEPROGRAMNVPROC pglExecuteProgramNV=_Lazy_glExecuteProgramNV;
PFNGLGENPROGRAMSNVPROC pglGenProgramsNV=_Lazy_glGenProgramsNV;
PFNGLGETPROGRAMPARAMETERDVNVPROC pglGetProgramParameterdvNV=_Lazy_glGetProgramParameterdvNV;
PFNGLGETPROGRAMPARAMETERFVNVPROC pglGetProgramParameterfvNV=_Lazy_glGetProgramParameterfvNV;
PFNGLGETPROGRAMIVNVPROC pglGetProgramivNV=_Lazy_glGetProgramivNV;
PFNGLGETPROGRAMSTRINGNVPROC pglGetProgramStringNV=_Lazy_glGetProgramStringNV;
PFNGLGETTRACKMATRIXIVNVPROC pglGetTrackMatrixivNV=_Lazy_glGetTrackMatrixivNV;
PFNGLGETVERTEXATTRIBDVNVPROC pglGetVertexAttribdvNV=_Lazy_glGetVertexAttribdvNV;
PFNGLGETVERTEXATTRIBFVNVPROC pglGetVertexAttribfvNV=_Lazy_glGetVertexAttribfvNV;
PFNGLGETVERTEXATTRIBIVNVPROC pglGetVertexAttribivNV=_Lazy_glGetVertexAttribivNV;
PFNGLGETVERTEXATTRIBPOINTERVNVPROC pglGetVertexAttribPointervNV=_Lazy_glGetVertexAttribPointervNV;
PFNGLISPROGRAMNVPROC pglIsProgramNV=_Lazy_glIsProgramNV;
PFNGLLOADPROGRAMNVPROC pglLoadProgramNV=_Lazy_glLoadProgramNV;
PFNGLPROGRAMPARAMETER4DNVPROC pglProgramParameter4dNV=_Lazy_glProgramParameter4dNV;
PFNGLPROGRAMPARAMETER4DVNVPROC pglProgramParameter4dvNV=_Lazy_glProgramParameter4dvNV;
PFNGLPROGRAMPARAMETER4FNVPROC pglProgramParameter4fNV=_Lazy_glProgramParameter4fNV;
PFNGLPROGRAMPARAMETER4FVNVPROC pglProgramParameter4fvNV=_Lazy_glProgramParameter4fvNV;
PFNGLPROGRAMPARAMETERS4DVNVPROC pglProgramParameters4dvNV=_Lazy_glProgramParameters4dvNV;
PFNGLPROGRAMPARAMETERS4FVNVPROC pglProgramParameters4fvNV=_Lazy_glProgramParameters4fvNV;
PFNGLREQUESTRESIDENTPROGRAMSNVPROC pglRequestResidentProgramsNV=_Lazy_glRequestResidentProgramsNV;
PFNGLTRACKMATRIXNVPROC pglTrackMatrixNV=_Lazy_glTrackMatrixNV;
PFNGLVERTEXATTRIBPOINTERNVPROC pglVertexAttribPointerNV=_Lazy_glVertexAttribPointerNV;
PFNGLVERTEXATTRIB1DNVPROC pglVertexAttrib1dNV=_Lazy_glVertexAttrib1dNV;
PFNGLVERTEXATTRIB1DVNVPROC pglVertexAttrib1dvNV=_Lazy_glVertexAttrib1dvNV;
PFNGLVERTEXATTRIB1FNVPROC pglVertexAttrib1fNV=_Lazy_glVertexAttrib1fNV;
PFNGLVERTEXATTRIB1FVNVPROC pglVertexAttrib1fvNV=_Lazy_glVertexAttrib1fvNV;
PFNGLVERTEXATTRIB1SNVPROC pglVertexAttrib1sNV=_Lazy_glVertexAttrib1sNV;
PFNGLVERTEXATTRIB1SVNVPROC pglVertexAttrib1svNV=_Lazy_glVertexAttrib1svNV;
PFNGLVERTEXATTRIB2DNVPROC pglVertexAttrib2dNV=_Lazy_glVertexAttrib2dNV;
PFNGLVERTEXATTRIB2DVNVPROC pglVertexAttrib2dvNV=_Lazy_glVertexAttrib2dvNV;
PFNGLVERTEXATTRIB2FNVPROC pglVertexAttrib2fNV=_Lazy_glVertexAttrib2fNV;
PFNGLVERTEXATTRIB2FVNVPROC pglVertexAttrib2fvNV=_Lazy_glVertexAttrib2fvNV;
PFNGLVERTEXATTRIB2SNVPROC pglVertexAttrib2sNV=_Lazy_glVertexAttrib2sNV;
PFNGLVERTEXATTRIB2SVNVPROC pglVertexAttrib2svNV=_Lazy_glVertexAttrib2svNV;
PFNGLVERTEXATTRIB3DNVPROC pglVertexAttrib3dNV=_Lazy_glVertexAttrib3dNV;
PFNGLVERTEXATTRIB3DVNVPROC pglVertexAttrib3dvNV=_Lazy_glVertexAttrib3dvNV;
PFNGLVERTEXATTRIB3FNVPROC pglVertexAttrib3fNV=_Lazy_glVertexAttrib3fNV;
PFNGLVERTEXATTRIB3FVNVPROC pglVertexAttrib3fvNV=_Lazy_glVertexAttrib3fvNV;
PFNGLVERTEXATTRIB3SNVPROC pglVertexAttrib3sNV=_Lazy_glVertexAttrib3sNV;
PFNGLVERTEXATTRIB3SVNVPROC pglVertexAttrib3svNV=_Lazy_glVertexAttrib3svNV;
PFNGLVERTEXATTRIB4DNVPROC pglVertexAttrib4dNV=_Lazy_glVertexAttrib4dNV;
PFNGLVERTEXATTRIB4DVNVPROC pglVertexAttrib4dvNV=_Lazy_glVertexAttrib4dvNV;
PFNGLVERTEXATTRIB4FNVPROC pglVertexAttrib4fNV=_Lazy_glVertexAttrib4fNV;
PFNGLVERTEXATTRIB4FVNVPROC pglVertexAttrib4fvNV=_Lazy_glVertexAttrib4fvNV;
PFNGLVERTEXATTRIB4SNVPROC pglVertexAttrib4sNV=_Lazy_glVertexAttrib4sNV;
PFNGLVERTEXATTRIB4SVNVPROC pglVertexAttrib4svNV=_Lazy_glVertexAttrib4svNV;
PFNGLVERTEXATTRIB4UBNVPROC pglVertexAttrib4ubNV=_Lazy_glVertexAttrib4ubNV;
PFNGLVERTEXATTRIB4UBVNVPROC pglVertexAttrib4ubvNV=_Lazy_glVertexAttrib4ubvNV;
PFNGLVERTEXATTRIBS1DVNVPROC pglVertexAttribs1dvNV=_Lazy_glVertexAttribs1dvNV;
PFNGLVERTEXATTRIBS1FVNVPROC pglVertexAttribs1fvNV=_Lazy_glVertexAttribs1fvNV;
PFNGLVERTEXATTRIBS1SVNVPROC pglVertexAttribs1svNV=_Lazy_glVertexAttribs1svNV;
PFNGLVERTEXATTRIBS2DVNVPROC pglVertexAttribs2dvNV=_Lazy_glVertexAttribs2dvNV;
PFNGLVERTEXATTRIBS2FVNVPROC pglVertexAttribs2fvNV=_Lazy_glVertexAttribs2fvNV;
PFNGLVERTEXATTRIBS2SVNVPROC pglVertexAttribs2svNV=_Lazy_glVertexAttribs2svNV;
PFNGLVERTEXATTRIBS3DVNVPROC pglVertexAttribs3dvNV=_Lazy_glVertexAttribs3dvNV;
PFNGLVERTEXATTRIBS3FVNVPROC pglVertexAttribs3fvNV=_Lazy_glVertexAttribs3fvNV;
PFNGLVERTEXATTRIBS3SVNVPROC pglVertexAttribs3svNV=_Lazy_glVertexAttribs3svNV;
PFNGLVERTEXATTRIBS4DVNVPROC pglVertexAttribs4dvNV=_Lazy_glVertexAttribs4dvNV;
PFNGLVERTEXATTRIBS4FVNVPROC pglVertexAttribs4fvNV=_Lazy_glVertexAttribs4fvNV;
PFNGLVERTEXATTRIBS4SVNVPROC pglVertexAttribs4svNV=_Lazy_glVertexAttribs4svNV;
PFNGLVERTEXATTRIBS4UBVNVPROC pglVertexAttribs4ubvNV=_Lazy_glVertexAttribs4ubvNV;
#endif
/* GL_SGIX_texture_coordinate_clamp */
#ifdef __GLEE_GL_SGIX_texture_coordinate_clamp
#endif
/* GL_SGIX_scalebias_hint */
#ifdef __GLEE_GL_SGIX_scalebias_hint
#endif
/* GL_OML_interlace */
#ifdef __GLEE_GL_OML_interlace
#endif
/* GL_OML_subsample */
#ifdef __GLEE_GL_OML_subsample
#endif
/* GL_OML_resample */
#ifdef __GLEE_GL_OML_resample
#endif
/* GL_NV_copy_depth_to_color */
#ifdef __GLEE_GL_NV_copy_depth_to_color
#endif
/* GL_ATI_envmap_bumpmap */
#ifdef __GLEE_GL_ATI_envmap_bumpmap
void __stdcall _Lazy_glTexBumpParameterivATI(GLenum pname, const GLint * param) {if (GLeeInit()) glTexBumpParameterivATI(pname, param);}
void __stdcall _Lazy_glTexBumpParameterfvATI(GLenum pname, const GLfloat * param) {if (GLeeInit()) glTexBumpParameterfvATI(pname, param);}
void __stdcall _Lazy_glGetTexBumpParameterivATI(GLenum pname, GLint * param) {if (GLeeInit()) glGetTexBumpParameterivATI(pname, param);}
void __stdcall _Lazy_glGetTexBumpParameterfvATI(GLenum pname, GLfloat * param) {if (GLeeInit()) glGetTexBumpParameterfvATI(pname, param);}
PFNGLTEXBUMPPARAMETERIVATIPROC pglTexBumpParameterivATI=_Lazy_glTexBumpParameterivATI;
PFNGLTEXBUMPPARAMETERFVATIPROC pglTexBumpParameterfvATI=_Lazy_glTexBumpParameterfvATI;
PFNGLGETTEXBUMPPARAMETERIVATIPROC pglGetTexBumpParameterivATI=_Lazy_glGetTexBumpParameterivATI;
PFNGLGETTEXBUMPPARAMETERFVATIPROC pglGetTexBumpParameterfvATI=_Lazy_glGetTexBumpParameterfvATI;
#endif
/* GL_ATI_fragment_shader */
#ifdef __GLEE_GL_ATI_fragment_shader
GLuint __stdcall _Lazy_glGenFragmentShadersATI(GLuint range) {if (GLeeInit()) return glGenFragmentShadersATI(range); return (GLuint)0;}
void __stdcall _Lazy_glBindFragmentShaderATI(GLuint id) {if (GLeeInit()) glBindFragmentShaderATI(id);}
void __stdcall _Lazy_glDeleteFragmentShaderATI(GLuint id) {if (GLeeInit()) glDeleteFragmentShaderATI(id);}
void __stdcall _Lazy_glBeginFragmentShaderATI(void) {if (GLeeInit()) glBeginFragmentShaderATI();}
void __stdcall _Lazy_glEndFragmentShaderATI(void) {if (GLeeInit()) glEndFragmentShaderATI();}
void __stdcall _Lazy_glPassTexCoordATI(GLuint dst, GLuint coord, GLenum swizzle) {if (GLeeInit()) glPassTexCoordATI(dst, coord, swizzle);}
void __stdcall _Lazy_glSampleMapATI(GLuint dst, GLuint interp, GLenum swizzle) {if (GLeeInit()) glSampleMapATI(dst, interp, swizzle);}
void __stdcall _Lazy_glColorFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod) {if (GLeeInit()) glColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);}
void __stdcall _Lazy_glColorFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod) {if (GLeeInit()) glColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);}
void __stdcall _Lazy_glColorFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod) {if (GLeeInit()) glColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);}
void __stdcall _Lazy_glAlphaFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod) {if (GLeeInit()) glAlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod);}
void __stdcall _Lazy_glAlphaFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod) {if (GLeeInit()) glAlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);}
void __stdcall _Lazy_glAlphaFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod) {if (GLeeInit()) glAlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);}
void __stdcall _Lazy_glSetFragmentShaderConstantATI(GLuint dst, const GLfloat * value) {if (GLeeInit()) glSetFragmentShaderConstantATI(dst, value);}
PFNGLGENFRAGMENTSHADERSATIPROC pglGenFragmentShadersATI=_Lazy_glGenFragmentShadersATI;
PFNGLBINDFRAGMENTSHADERATIPROC pglBindFragmentShaderATI=_Lazy_glBindFragmentShaderATI;
PFNGLDELETEFRAGMENTSHADERATIPROC pglDeleteFragmentShaderATI=_Lazy_glDeleteFragmentShaderATI;
PFNGLBEGINFRAGMENTSHADERATIPROC pglBeginFragmentShaderATI=_Lazy_glBeginFragmentShaderATI;
PFNGLENDFRAGMENTSHADERATIPROC pglEndFragmentShaderATI=_Lazy_glEndFragmentShaderATI;
PFNGLPASSTEXCOORDATIPROC pglPassTexCoordATI=_Lazy_glPassTexCoordATI;
PFNGLSAMPLEMAPATIPROC pglSampleMapATI=_Lazy_glSampleMapATI;
PFNGLCOLORFRAGMENTOP1ATIPROC pglColorFragmentOp1ATI=_Lazy_glColorFragmentOp1ATI;
PFNGLCOLORFRAGMENTOP2ATIPROC pglColorFragmentOp2ATI=_Lazy_glColorFragmentOp2ATI;
PFNGLCOLORFRAGMENTOP3ATIPROC pglColorFragmentOp3ATI=_Lazy_glColorFragmentOp3ATI;
PFNGLALPHAFRAGMENTOP1ATIPROC pglAlphaFragmentOp1ATI=_Lazy_glAlphaFragmentOp1ATI;
PFNGLALPHAFRAGMENTOP2ATIPROC pglAlphaFragmentOp2ATI=_Lazy_glAlphaFragmentOp2ATI;
PFNGLALPHAFRAGMENTOP3ATIPROC pglAlphaFragmentOp3ATI=_Lazy_glAlphaFragmentOp3ATI;
PFNGLSETFRAGMENTSHADERCONSTANTATIPROC pglSetFragmentShaderConstantATI=_Lazy_glSetFragmentShaderConstantATI;
#endif
/* GL_ATI_pn_triangles */
#ifdef __GLEE_GL_ATI_pn_triangles
void __stdcall _Lazy_glPNTrianglesiATI(GLenum pname, GLint param) {if (GLeeInit()) glPNTrianglesiATI(pname, param);}
void __stdcall _Lazy_glPNTrianglesfATI(GLenum pname, GLfloat param) {if (GLeeInit()) glPNTrianglesfATI(pname, param);}
PFNGLPNTRIANGLESIATIPROC pglPNTrianglesiATI=_Lazy_glPNTrianglesiATI;
PFNGLPNTRIANGLESFATIPROC pglPNTrianglesfATI=_Lazy_glPNTrianglesfATI;
#endif
/* GL_ATI_vertex_array_object */
#ifdef __GLEE_GL_ATI_vertex_array_object
GLuint __stdcall _Lazy_glNewObjectBufferATI(GLsizei size, const GLvoid * pointer, GLenum usage) {if (GLeeInit()) return glNewObjectBufferATI(size, pointer, usage); return (GLuint)0;}
GLboolean __stdcall _Lazy_glIsObjectBufferATI(GLuint buffer) {if (GLeeInit()) return glIsObjectBufferATI(buffer); return (GLboolean)0;}
void __stdcall _Lazy_glUpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, const GLvoid * pointer, GLenum preserve) {if (GLeeInit()) glUpdateObjectBufferATI(buffer, offset, size, pointer, preserve);}
void __stdcall _Lazy_glGetObjectBufferfvATI(GLuint buffer, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetObjectBufferfvATI(buffer, pname, params);}
void __stdcall _Lazy_glGetObjectBufferivATI(GLuint buffer, GLenum pname, GLint * params) {if (GLeeInit()) glGetObjectBufferivATI(buffer, pname, params);}
void __stdcall _Lazy_glFreeObjectBufferATI(GLuint buffer) {if (GLeeInit()) glFreeObjectBufferATI(buffer);}
void __stdcall _Lazy_glArrayObjectATI(GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset) {if (GLeeInit()) glArrayObjectATI(array, size, type, stride, buffer, offset);}
void __stdcall _Lazy_glGetArrayObjectfvATI(GLenum array, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetArrayObjectfvATI(array, pname, params);}
void __stdcall _Lazy_glGetArrayObjectivATI(GLenum array, GLenum pname, GLint * params) {if (GLeeInit()) glGetArrayObjectivATI(array, pname, params);}
void __stdcall _Lazy_glVariantArrayObjectATI(GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset) {if (GLeeInit()) glVariantArrayObjectATI(id, type, stride, buffer, offset);}
void __stdcall _Lazy_glGetVariantArrayObjectfvATI(GLuint id, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetVariantArrayObjectfvATI(id, pname, params);}
void __stdcall _Lazy_glGetVariantArrayObjectivATI(GLuint id, GLenum pname, GLint * params) {if (GLeeInit()) glGetVariantArrayObjectivATI(id, pname, params);}
PFNGLNEWOBJECTBUFFERATIPROC pglNewObjectBufferATI=_Lazy_glNewObjectBufferATI;
PFNGLISOBJECTBUFFERATIPROC pglIsObjectBufferATI=_Lazy_glIsObjectBufferATI;
PFNGLUPDATEOBJECTBUFFERATIPROC pglUpdateObjectBufferATI=_Lazy_glUpdateObjectBufferATI;
PFNGLGETOBJECTBUFFERFVATIPROC pglGetObjectBufferfvATI=_Lazy_glGetObjectBufferfvATI;
PFNGLGETOBJECTBUFFERIVATIPROC pglGetObjectBufferivATI=_Lazy_glGetObjectBufferivATI;
PFNGLFREEOBJECTBUFFERATIPROC pglFreeObjectBufferATI=_Lazy_glFreeObjectBufferATI;
PFNGLARRAYOBJECTATIPROC pglArrayObjectATI=_Lazy_glArrayObjectATI;
PFNGLGETARRAYOBJECTFVATIPROC pglGetArrayObjectfvATI=_Lazy_glGetArrayObjectfvATI;
PFNGLGETARRAYOBJECTIVATIPROC pglGetArrayObjectivATI=_Lazy_glGetArrayObjectivATI;
PFNGLVARIANTARRAYOBJECTATIPROC pglVariantArrayObjectATI=_Lazy_glVariantArrayObjectATI;
PFNGLGETVARIANTARRAYOBJECTFVATIPROC pglGetVariantArrayObjectfvATI=_Lazy_glGetVariantArrayObjectfvATI;
PFNGLGETVARIANTARRAYOBJECTIVATIPROC pglGetVariantArrayObjectivATI=_Lazy_glGetVariantArrayObjectivATI;
#endif
/* GL_EXT_vertex_shader */
#ifdef __GLEE_GL_EXT_vertex_shader
void __stdcall _Lazy_glBeginVertexShaderEXT(void) {if (GLeeInit()) glBeginVertexShaderEXT();}
void __stdcall _Lazy_glEndVertexShaderEXT(void) {if (GLeeInit()) glEndVertexShaderEXT();}
void __stdcall _Lazy_glBindVertexShaderEXT(GLuint id) {if (GLeeInit()) glBindVertexShaderEXT(id);}
GLuint __stdcall _Lazy_glGenVertexShadersEXT(GLuint range) {if (GLeeInit()) return glGenVertexShadersEXT(range); return (GLuint)0;}
void __stdcall _Lazy_glDeleteVertexShaderEXT(GLuint id) {if (GLeeInit()) glDeleteVertexShaderEXT(id);}
void __stdcall _Lazy_glShaderOp1EXT(GLenum op, GLuint res, GLuint arg1) {if (GLeeInit()) glShaderOp1EXT(op, res, arg1);}
void __stdcall _Lazy_glShaderOp2EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2) {if (GLeeInit()) glShaderOp2EXT(op, res, arg1, arg2);}
void __stdcall _Lazy_glShaderOp3EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3) {if (GLeeInit()) glShaderOp3EXT(op, res, arg1, arg2, arg3);}
void __stdcall _Lazy_glSwizzleEXT(GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW) {if (GLeeInit()) glSwizzleEXT(res, in, outX, outY, outZ, outW);}
void __stdcall _Lazy_glWriteMaskEXT(GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW) {if (GLeeInit()) glWriteMaskEXT(res, in, outX, outY, outZ, outW);}
void __stdcall _Lazy_glInsertComponentEXT(GLuint res, GLuint src, GLuint num) {if (GLeeInit()) glInsertComponentEXT(res, src, num);}
void __stdcall _Lazy_glExtractComponentEXT(GLuint res, GLuint src, GLuint num) {if (GLeeInit()) glExtractComponentEXT(res, src, num);}
GLuint __stdcall _Lazy_glGenSymbolsEXT(GLenum datatype, GLenum storagetype, GLenum range, GLuint components) {if (GLeeInit()) return glGenSymbolsEXT(datatype, storagetype, range, components); return (GLuint)0;}
void __stdcall _Lazy_glSetInvariantEXT(GLuint id, GLenum type, const GLvoid * addr) {if (GLeeInit()) glSetInvariantEXT(id, type, addr);}
void __stdcall _Lazy_glSetLocalConstantEXT(GLuint id, GLenum type, const GLvoid * addr) {if (GLeeInit()) glSetLocalConstantEXT(id, type, addr);}
void __stdcall _Lazy_glVariantbvEXT(GLuint id, const GLbyte * addr) {if (GLeeInit()) glVariantbvEXT(id, addr);}
void __stdcall _Lazy_glVariantsvEXT(GLuint id, const GLshort * addr) {if (GLeeInit()) glVariantsvEXT(id, addr);}
void __stdcall _Lazy_glVariantivEXT(GLuint id, const GLint * addr) {if (GLeeInit()) glVariantivEXT(id, addr);}
void __stdcall _Lazy_glVariantfvEXT(GLuint id, const GLfloat * addr) {if (GLeeInit()) glVariantfvEXT(id, addr);}
void __stdcall _Lazy_glVariantdvEXT(GLuint id, const GLdouble * addr) {if (GLeeInit()) glVariantdvEXT(id, addr);}
void __stdcall _Lazy_glVariantubvEXT(GLuint id, const GLubyte * addr) {if (GLeeInit()) glVariantubvEXT(id, addr);}
void __stdcall _Lazy_glVariantusvEXT(GLuint id, const GLushort * addr) {if (GLeeInit()) glVariantusvEXT(id, addr);}
void __stdcall _Lazy_glVariantuivEXT(GLuint id, const GLuint * addr) {if (GLeeInit()) glVariantuivEXT(id, addr);}
void __stdcall _Lazy_glVariantPointerEXT(GLuint id, GLenum type, GLuint stride, const GLvoid * addr) {if (GLeeInit()) glVariantPointerEXT(id, type, stride, addr);}
void __stdcall _Lazy_glEnableVariantClientStateEXT(GLuint id) {if (GLeeInit()) glEnableVariantClientStateEXT(id);}
void __stdcall _Lazy_glDisableVariantClientStateEXT(GLuint id) {if (GLeeInit()) glDisableVariantClientStateEXT(id);}
GLuint __stdcall _Lazy_glBindLightParameterEXT(GLenum light, GLenum value) {if (GLeeInit()) return glBindLightParameterEXT(light, value); return (GLuint)0;}
GLuint __stdcall _Lazy_glBindMaterialParameterEXT(GLenum face, GLenum value) {if (GLeeInit()) return glBindMaterialParameterEXT(face, value); return (GLuint)0;}
GLuint __stdcall _Lazy_glBindTexGenParameterEXT(GLenum unit, GLenum coord, GLenum value) {if (GLeeInit()) return glBindTexGenParameterEXT(unit, coord, value); return (GLuint)0;}
GLuint __stdcall _Lazy_glBindTextureUnitParameterEXT(GLenum unit, GLenum value) {if (GLeeInit()) return glBindTextureUnitParameterEXT(unit, value); return (GLuint)0;}
GLuint __stdcall _Lazy_glBindParameterEXT(GLenum value) {if (GLeeInit()) return glBindParameterEXT(value); return (GLuint)0;}
GLboolean __stdcall _Lazy_glIsVariantEnabledEXT(GLuint id, GLenum cap) {if (GLeeInit()) return glIsVariantEnabledEXT(id, cap); return (GLboolean)0;}
void __stdcall _Lazy_glGetVariantBooleanvEXT(GLuint id, GLenum value, GLboolean * data) {if (GLeeInit()) glGetVariantBooleanvEXT(id, value, data);}
void __stdcall _Lazy_glGetVariantIntegervEXT(GLuint id, GLenum value, GLint * data) {if (GLeeInit()) glGetVariantIntegervEXT(id, value, data);}
void __stdcall _Lazy_glGetVariantFloatvEXT(GLuint id, GLenum value, GLfloat * data) {if (GLeeInit()) glGetVariantFloatvEXT(id, value, data);}
void __stdcall _Lazy_glGetVariantPointervEXT(GLuint id, GLenum value, GLvoid* * data) {if (GLeeInit()) glGetVariantPointervEXT(id, value, data);}
void __stdcall _Lazy_glGetInvariantBooleanvEXT(GLuint id, GLenum value, GLboolean * data) {if (GLeeInit()) glGetInvariantBooleanvEXT(id, value, data);}
void __stdcall _Lazy_glGetInvariantIntegervEXT(GLuint id, GLenum value, GLint * data) {if (GLeeInit()) glGetInvariantIntegervEXT(id, value, data);}
void __stdcall _Lazy_glGetInvariantFloatvEXT(GLuint id, GLenum value, GLfloat * data) {if (GLeeInit()) glGetInvariantFloatvEXT(id, value, data);}
void __stdcall _Lazy_glGetLocalConstantBooleanvEXT(GLuint id, GLenum value, GLboolean * data) {if (GLeeInit()) glGetLocalConstantBooleanvEXT(id, value, data);}
void __stdcall _Lazy_glGetLocalConstantIntegervEXT(GLuint id, GLenum value, GLint * data) {if (GLeeInit()) glGetLocalConstantIntegervEXT(id, value, data);}
void __stdcall _Lazy_glGetLocalConstantFloatvEXT(GLuint id, GLenum value, GLfloat * data) {if (GLeeInit()) glGetLocalConstantFloatvEXT(id, value, data);}
PFNGLBEGINVERTEXSHADEREXTPROC pglBeginVertexShaderEXT=_Lazy_glBeginVertexShaderEXT;
PFNGLENDVERTEXSHADEREXTPROC pglEndVertexShaderEXT=_Lazy_glEndVertexShaderEXT;
PFNGLBINDVERTEXSHADEREXTPROC pglBindVertexShaderEXT=_Lazy_glBindVertexShaderEXT;
PFNGLGENVERTEXSHADERSEXTPROC pglGenVertexShadersEXT=_Lazy_glGenVertexShadersEXT;
PFNGLDELETEVERTEXSHADEREXTPROC pglDeleteVertexShaderEXT=_Lazy_glDeleteVertexShaderEXT;
PFNGLSHADEROP1EXTPROC pglShaderOp1EXT=_Lazy_glShaderOp1EXT;
PFNGLSHADEROP2EXTPROC pglShaderOp2EXT=_Lazy_glShaderOp2EXT;
PFNGLSHADEROP3EXTPROC pglShaderOp3EXT=_Lazy_glShaderOp3EXT;
PFNGLSWIZZLEEXTPROC pglSwizzleEXT=_Lazy_glSwizzleEXT;
PFNGLWRITEMASKEXTPROC pglWriteMaskEXT=_Lazy_glWriteMaskEXT;
PFNGLINSERTCOMPONENTEXTPROC pglInsertComponentEXT=_Lazy_glInsertComponentEXT;
PFNGLEXTRACTCOMPONENTEXTPROC pglExtractComponentEXT=_Lazy_glExtractComponentEXT;
PFNGLGENSYMBOLSEXTPROC pglGenSymbolsEXT=_Lazy_glGenSymbolsEXT;
PFNGLSETINVARIANTEXTPROC pglSetInvariantEXT=_Lazy_glSetInvariantEXT;
PFNGLSETLOCALCONSTANTEXTPROC pglSetLocalConstantEXT=_Lazy_glSetLocalConstantEXT;
PFNGLVARIANTBVEXTPROC pglVariantbvEXT=_Lazy_glVariantbvEXT;
PFNGLVARIANTSVEXTPROC pglVariantsvEXT=_Lazy_glVariantsvEXT;
PFNGLVARIANTIVEXTPROC pglVariantivEXT=_Lazy_glVariantivEXT;
PFNGLVARIANTFVEXTPROC pglVariantfvEXT=_Lazy_glVariantfvEXT;
PFNGLVARIANTDVEXTPROC pglVariantdvEXT=_Lazy_glVariantdvEXT;
PFNGLVARIANTUBVEXTPROC pglVariantubvEXT=_Lazy_glVariantubvEXT;
PFNGLVARIANTUSVEXTPROC pglVariantusvEXT=_Lazy_glVariantusvEXT;
PFNGLVARIANTUIVEXTPROC pglVariantuivEXT=_Lazy_glVariantuivEXT;
PFNGLVARIANTPOINTEREXTPROC pglVariantPointerEXT=_Lazy_glVariantPointerEXT;
PFNGLENABLEVARIANTCLIENTSTATEEXTPROC pglEnableVariantClientStateEXT=_Lazy_glEnableVariantClientStateEXT;
PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC pglDisableVariantClientStateEXT=_Lazy_glDisableVariantClientStateEXT;
PFNGLBINDLIGHTPARAMETEREXTPROC pglBindLightParameterEXT=_Lazy_glBindLightParameterEXT;
PFNGLBINDMATERIALPARAMETEREXTPROC pglBindMaterialParameterEXT=_Lazy_glBindMaterialParameterEXT;
PFNGLBINDTEXGENPARAMETEREXTPROC pglBindTexGenParameterEXT=_Lazy_glBindTexGenParameterEXT;
PFNGLBINDTEXTUREUNITPARAMETEREXTPROC pglBindTextureUnitParameterEXT=_Lazy_glBindTextureUnitParameterEXT;
PFNGLBINDPARAMETEREXTPROC pglBindParameterEXT=_Lazy_glBindParameterEXT;
PFNGLISVARIANTENABLEDEXTPROC pglIsVariantEnabledEXT=_Lazy_glIsVariantEnabledEXT;
PFNGLGETVARIANTBOOLEANVEXTPROC pglGetVariantBooleanvEXT=_Lazy_glGetVariantBooleanvEXT;
PFNGLGETVARIANTINTEGERVEXTPROC pglGetVariantIntegervEXT=_Lazy_glGetVariantIntegervEXT;
PFNGLGETVARIANTFLOATVEXTPROC pglGetVariantFloatvEXT=_Lazy_glGetVariantFloatvEXT;
PFNGLGETVARIANTPOINTERVEXTPROC pglGetVariantPointervEXT=_Lazy_glGetVariantPointervEXT;
PFNGLGETINVARIANTBOOLEANVEXTPROC pglGetInvariantBooleanvEXT=_Lazy_glGetInvariantBooleanvEXT;
PFNGLGETINVARIANTINTEGERVEXTPROC pglGetInvariantIntegervEXT=_Lazy_glGetInvariantIntegervEXT;
PFNGLGETINVARIANTFLOATVEXTPROC pglGetInvariantFloatvEXT=_Lazy_glGetInvariantFloatvEXT;
PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC pglGetLocalConstantBooleanvEXT=_Lazy_glGetLocalConstantBooleanvEXT;
PFNGLGETLOCALCONSTANTINTEGERVEXTPROC pglGetLocalConstantIntegervEXT=_Lazy_glGetLocalConstantIntegervEXT;
PFNGLGETLOCALCONSTANTFLOATVEXTPROC pglGetLocalConstantFloatvEXT=_Lazy_glGetLocalConstantFloatvEXT;
#endif
/* GL_ATI_vertex_streams */
#ifdef __GLEE_GL_ATI_vertex_streams
void __stdcall _Lazy_glVertexStream1sATI(GLenum stream, GLshort x) {if (GLeeInit()) glVertexStream1sATI(stream, x);}
void __stdcall _Lazy_glVertexStream1svATI(GLenum stream, const GLshort * coords) {if (GLeeInit()) glVertexStream1svATI(stream, coords);}
void __stdcall _Lazy_glVertexStream1iATI(GLenum stream, GLint x) {if (GLeeInit()) glVertexStream1iATI(stream, x);}
void __stdcall _Lazy_glVertexStream1ivATI(GLenum stream, const GLint * coords) {if (GLeeInit()) glVertexStream1ivATI(stream, coords);}
void __stdcall _Lazy_glVertexStream1fATI(GLenum stream, GLfloat x) {if (GLeeInit()) glVertexStream1fATI(stream, x);}
void __stdcall _Lazy_glVertexStream1fvATI(GLenum stream, const GLfloat * coords) {if (GLeeInit()) glVertexStream1fvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream1dATI(GLenum stream, GLdouble x) {if (GLeeInit()) glVertexStream1dATI(stream, x);}
void __stdcall _Lazy_glVertexStream1dvATI(GLenum stream, const GLdouble * coords) {if (GLeeInit()) glVertexStream1dvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream2sATI(GLenum stream, GLshort x, GLshort y) {if (GLeeInit()) glVertexStream2sATI(stream, x, y);}
void __stdcall _Lazy_glVertexStream2svATI(GLenum stream, const GLshort * coords) {if (GLeeInit()) glVertexStream2svATI(stream, coords);}
void __stdcall _Lazy_glVertexStream2iATI(GLenum stream, GLint x, GLint y) {if (GLeeInit()) glVertexStream2iATI(stream, x, y);}
void __stdcall _Lazy_glVertexStream2ivATI(GLenum stream, const GLint * coords) {if (GLeeInit()) glVertexStream2ivATI(stream, coords);}
void __stdcall _Lazy_glVertexStream2fATI(GLenum stream, GLfloat x, GLfloat y) {if (GLeeInit()) glVertexStream2fATI(stream, x, y);}
void __stdcall _Lazy_glVertexStream2fvATI(GLenum stream, const GLfloat * coords) {if (GLeeInit()) glVertexStream2fvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream2dATI(GLenum stream, GLdouble x, GLdouble y) {if (GLeeInit()) glVertexStream2dATI(stream, x, y);}
void __stdcall _Lazy_glVertexStream2dvATI(GLenum stream, const GLdouble * coords) {if (GLeeInit()) glVertexStream2dvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream3sATI(GLenum stream, GLshort x, GLshort y, GLshort z) {if (GLeeInit()) glVertexStream3sATI(stream, x, y, z);}
void __stdcall _Lazy_glVertexStream3svATI(GLenum stream, const GLshort * coords) {if (GLeeInit()) glVertexStream3svATI(stream, coords);}
void __stdcall _Lazy_glVertexStream3iATI(GLenum stream, GLint x, GLint y, GLint z) {if (GLeeInit()) glVertexStream3iATI(stream, x, y, z);}
void __stdcall _Lazy_glVertexStream3ivATI(GLenum stream, const GLint * coords) {if (GLeeInit()) glVertexStream3ivATI(stream, coords);}
void __stdcall _Lazy_glVertexStream3fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glVertexStream3fATI(stream, x, y, z);}
void __stdcall _Lazy_glVertexStream3fvATI(GLenum stream, const GLfloat * coords) {if (GLeeInit()) glVertexStream3fvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream3dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glVertexStream3dATI(stream, x, y, z);}
void __stdcall _Lazy_glVertexStream3dvATI(GLenum stream, const GLdouble * coords) {if (GLeeInit()) glVertexStream3dvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream4sATI(GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w) {if (GLeeInit()) glVertexStream4sATI(stream, x, y, z, w);}
void __stdcall _Lazy_glVertexStream4svATI(GLenum stream, const GLshort * coords) {if (GLeeInit()) glVertexStream4svATI(stream, coords);}
void __stdcall _Lazy_glVertexStream4iATI(GLenum stream, GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glVertexStream4iATI(stream, x, y, z, w);}
void __stdcall _Lazy_glVertexStream4ivATI(GLenum stream, const GLint * coords) {if (GLeeInit()) glVertexStream4ivATI(stream, coords);}
void __stdcall _Lazy_glVertexStream4fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glVertexStream4fATI(stream, x, y, z, w);}
void __stdcall _Lazy_glVertexStream4fvATI(GLenum stream, const GLfloat * coords) {if (GLeeInit()) glVertexStream4fvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream4dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glVertexStream4dATI(stream, x, y, z, w);}
void __stdcall _Lazy_glVertexStream4dvATI(GLenum stream, const GLdouble * coords) {if (GLeeInit()) glVertexStream4dvATI(stream, coords);}
void __stdcall _Lazy_glNormalStream3bATI(GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz) {if (GLeeInit()) glNormalStream3bATI(stream, nx, ny, nz);}
void __stdcall _Lazy_glNormalStream3bvATI(GLenum stream, const GLbyte * coords) {if (GLeeInit()) glNormalStream3bvATI(stream, coords);}
void __stdcall _Lazy_glNormalStream3sATI(GLenum stream, GLshort nx, GLshort ny, GLshort nz) {if (GLeeInit()) glNormalStream3sATI(stream, nx, ny, nz);}
void __stdcall _Lazy_glNormalStream3svATI(GLenum stream, const GLshort * coords) {if (GLeeInit()) glNormalStream3svATI(stream, coords);}
void __stdcall _Lazy_glNormalStream3iATI(GLenum stream, GLint nx, GLint ny, GLint nz) {if (GLeeInit()) glNormalStream3iATI(stream, nx, ny, nz);}
void __stdcall _Lazy_glNormalStream3ivATI(GLenum stream, const GLint * coords) {if (GLeeInit()) glNormalStream3ivATI(stream, coords);}
void __stdcall _Lazy_glNormalStream3fATI(GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz) {if (GLeeInit()) glNormalStream3fATI(stream, nx, ny, nz);}
void __stdcall _Lazy_glNormalStream3fvATI(GLenum stream, const GLfloat * coords) {if (GLeeInit()) glNormalStream3fvATI(stream, coords);}
void __stdcall _Lazy_glNormalStream3dATI(GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz) {if (GLeeInit()) glNormalStream3dATI(stream, nx, ny, nz);}
void __stdcall _Lazy_glNormalStream3dvATI(GLenum stream, const GLdouble * coords) {if (GLeeInit()) glNormalStream3dvATI(stream, coords);}
void __stdcall _Lazy_glClientActiveVertexStreamATI(GLenum stream) {if (GLeeInit()) glClientActiveVertexStreamATI(stream);}
void __stdcall _Lazy_glVertexBlendEnviATI(GLenum pname, GLint param) {if (GLeeInit()) glVertexBlendEnviATI(pname, param);}
void __stdcall _Lazy_glVertexBlendEnvfATI(GLenum pname, GLfloat param) {if (GLeeInit()) glVertexBlendEnvfATI(pname, param);}
PFNGLVERTEXSTREAM1SATIPROC pglVertexStream1sATI=_Lazy_glVertexStream1sATI;
PFNGLVERTEXSTREAM1SVATIPROC pglVertexStream1svATI=_Lazy_glVertexStream1svATI;
PFNGLVERTEXSTREAM1IATIPROC pglVertexStream1iATI=_Lazy_glVertexStream1iATI;
PFNGLVERTEXSTREAM1IVATIPROC pglVertexStream1ivATI=_Lazy_glVertexStream1ivATI;
PFNGLVERTEXSTREAM1FATIPROC pglVertexStream1fATI=_Lazy_glVertexStream1fATI;
PFNGLVERTEXSTREAM1FVATIPROC pglVertexStream1fvATI=_Lazy_glVertexStream1fvATI;
PFNGLVERTEXSTREAM1DATIPROC pglVertexStream1dATI=_Lazy_glVertexStream1dATI;
PFNGLVERTEXSTREAM1DVATIPROC pglVertexStream1dvATI=_Lazy_glVertexStream1dvATI;
PFNGLVERTEXSTREAM2SATIPROC pglVertexStream2sATI=_Lazy_glVertexStream2sATI;
PFNGLVERTEXSTREAM2SVATIPROC pglVertexStream2svATI=_Lazy_glVertexStream2svATI;
PFNGLVERTEXSTREAM2IATIPROC pglVertexStream2iATI=_Lazy_glVertexStream2iATI;
PFNGLVERTEXSTREAM2IVATIPROC pglVertexStream2ivATI=_Lazy_glVertexStream2ivATI;
PFNGLVERTEXSTREAM2FATIPROC pglVertexStream2fATI=_Lazy_glVertexStream2fATI;
PFNGLVERTEXSTREAM2FVATIPROC pglVertexStream2fvATI=_Lazy_glVertexStream2fvATI;
PFNGLVERTEXSTREAM2DATIPROC pglVertexStream2dATI=_Lazy_glVertexStream2dATI;
PFNGLVERTEXSTREAM2DVATIPROC pglVertexStream2dvATI=_Lazy_glVertexStream2dvATI;
PFNGLVERTEXSTREAM3SATIPROC pglVertexStream3sATI=_Lazy_glVertexStream3sATI;
PFNGLVERTEXSTREAM3SVATIPROC pglVertexStream3svATI=_Lazy_glVertexStream3svATI;
PFNGLVERTEXSTREAM3IATIPROC pglVertexStream3iATI=_Lazy_glVertexStream3iATI;
PFNGLVERTEXSTREAM3IVATIPROC pglVertexStream3ivATI=_Lazy_glVertexStream3ivATI;
PFNGLVERTEXSTREAM3FATIPROC pglVertexStream3fATI=_Lazy_glVertexStream3fATI;
PFNGLVERTEXSTREAM3FVATIPROC pglVertexStream3fvATI=_Lazy_glVertexStream3fvATI;
PFNGLVERTEXSTREAM3DATIPROC pglVertexStream3dATI=_Lazy_glVertexStream3dATI;
PFNGLVERTEXSTREAM3DVATIPROC pglVertexStream3dvATI=_Lazy_glVertexStream3dvATI;
PFNGLVERTEXSTREAM4SATIPROC pglVertexStream4sATI=_Lazy_glVertexStream4sATI;
PFNGLVERTEXSTREAM4SVATIPROC pglVertexStream4svATI=_Lazy_glVertexStream4svATI;
PFNGLVERTEXSTREAM4IATIPROC pglVertexStream4iATI=_Lazy_glVertexStream4iATI;
PFNGLVERTEXSTREAM4IVATIPROC pglVertexStream4ivATI=_Lazy_glVertexStream4ivATI;
PFNGLVERTEXSTREAM4FATIPROC pglVertexStream4fATI=_Lazy_glVertexStream4fATI;
PFNGLVERTEXSTREAM4FVATIPROC pglVertexStream4fvATI=_Lazy_glVertexStream4fvATI;
PFNGLVERTEXSTREAM4DATIPROC pglVertexStream4dATI=_Lazy_glVertexStream4dATI;
PFNGLVERTEXSTREAM4DVATIPROC pglVertexStream4dvATI=_Lazy_glVertexStream4dvATI;
PFNGLNORMALSTREAM3BATIPROC pglNormalStream3bATI=_Lazy_glNormalStream3bATI;
PFNGLNORMALSTREAM3BVATIPROC pglNormalStream3bvATI=_Lazy_glNormalStream3bvATI;
PFNGLNORMALSTREAM3SATIPROC pglNormalStream3sATI=_Lazy_glNormalStream3sATI;
PFNGLNORMALSTREAM3SVATIPROC pglNormalStream3svATI=_Lazy_glNormalStream3svATI;
PFNGLNORMALSTREAM3IATIPROC pglNormalStream3iATI=_Lazy_glNormalStream3iATI;
PFNGLNORMALSTREAM3IVATIPROC pglNormalStream3ivATI=_Lazy_glNormalStream3ivATI;
PFNGLNORMALSTREAM3FATIPROC pglNormalStream3fATI=_Lazy_glNormalStream3fATI;
PFNGLNORMALSTREAM3FVATIPROC pglNormalStream3fvATI=_Lazy_glNormalStream3fvATI;
PFNGLNORMALSTREAM3DATIPROC pglNormalStream3dATI=_Lazy_glNormalStream3dATI;
PFNGLNORMALSTREAM3DVATIPROC pglNormalStream3dvATI=_Lazy_glNormalStream3dvATI;
PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC pglClientActiveVertexStreamATI=_Lazy_glClientActiveVertexStreamATI;
PFNGLVERTEXBLENDENVIATIPROC pglVertexBlendEnviATI=_Lazy_glVertexBlendEnviATI;
PFNGLVERTEXBLENDENVFATIPROC pglVertexBlendEnvfATI=_Lazy_glVertexBlendEnvfATI;
#endif
/* GL_ATI_element_array */
#ifdef __GLEE_GL_ATI_element_array
void __stdcall _Lazy_glElementPointerATI(GLenum type, const GLvoid * pointer) {if (GLeeInit()) glElementPointerATI(type, pointer);}
void __stdcall _Lazy_glDrawElementArrayATI(GLenum mode, GLsizei count) {if (GLeeInit()) glDrawElementArrayATI(mode, count);}
void __stdcall _Lazy_glDrawRangeElementArrayATI(GLenum mode, GLuint start, GLuint end, GLsizei count) {if (GLeeInit()) glDrawRangeElementArrayATI(mode, start, end, count);}
PFNGLELEMENTPOINTERATIPROC pglElementPointerATI=_Lazy_glElementPointerATI;
PFNGLDRAWELEMENTARRAYATIPROC pglDrawElementArrayATI=_Lazy_glDrawElementArrayATI;