It's verification time!!! - Printable Version

Code: (Select All)
  'Ring 0 - kernel

  

  ' kernel mode libc

  declare proc k_f            (x  as uint8)                                                                  as float 

  declare proc k_f            (x  as int8)                                                                    as float

  declare proc k_f            (x  as uint16)                                                                  as float 

  declare proc k_f            (x  as int16)                                                                  as float 

  declare proc k_f            (x  as uint32)                                                                  as float 

  declare proc k_f            (x  as int32)                                                                  as float 

  declare proc k_f            (x  as uint64)                                                                  as float 

  declare proc k_f            (x  as int64)                                                                  as float                

  declare proc k_f            (x  as single)                                                                  as float  

  declare proc k_f            (x  as float)                                                                  as float

  declare proc k_f            (x  as FLOAT128)                                                                as float

  declare proc k_f            (x  as FLOAT256)                                                                as float

  declare proc k_f            (x  as FLOAT512)                                                                as float



  declare proc k_frexp        (d  as uint8      , ep        as uint8 ptr)                                  as float 

  declare proc k_frexp        (d  as int8        , ep        as int8 ptr)                                    as float 

  declare proc k_frexp        (d  as uint16      , ep        as uint16 ptr)                                  as float 

  declare proc k_frexp        (d  as int16      , ep        as int16 ptr)                                  as float 

  declare proc k_frexp        (d  as uint32      , ep        as uint32 ptr)                                  as float 

  declare proc k_frexp        (d  as int32      , ep        as int32 ptr)                                  as float 

  declare proc k_frexp        (d  as uint64      , ep        as uint64 ptr)                                  as float  

  declare proc k_frexp        (d  as int64      , ep        as int64 ptr)                                  as float  

  declare proc k_frexp        (d  as single      , ep        as single ptr)                                  as float    

  declare proc k_frexp        (d  as float      , ep        as float ptr)                                  as float

  declare proc k_frexp        (d  as FLOAT128    , ep        as FLOAT128 ptr)                                as float

  declare proc k_frexp        (d  as FLOAT256    , ep        as FLOAT256 ptr)                                as float

  declare proc k_frexp        (d  as FLOAT512    , ep        as FLOAT512 ptr)                                as float



  declare proc k_ldexp        (d  as uint8      , e          as uint8)                                      as float

  declare proc k_ldexp        (d  as int8        , e          as int8)                                        as float

  declare proc k_ldexp        (d  as uint16      , e          as uint16)                                      as float

  declare proc k_ldexp        (d  as int16      , e          as int16)                                      as float

  declare proc k_ldexp        (d  as uint32      , e          as uint32)                                      as float

  declare proc k_ldexp        (d  as int32      , e          as int32)                                      as float

  declare proc k_ldexp        (d  as uint64      , e          as uint64)                                      as float

  declare proc k_ldexp        (d  as int64      , e          as int64)                                      as float        

  declare proc k_ldexp        (d  as single      , e          as single)                                      as float

  declare proc k_ldexp        (d  as float      , e          as float)                                      as float

  declare proc k_ldexp        (d  as FLOAT128    , e          as FLOAT128)                                    as float

  declare proc k_ldexp        (d  as FLOAT256    , e          as FLOAT256)                                    as float

  declare proc k_ldexp        (d  as FLOAT512    , e          as FLOAT512)                                    as float



  declare proc k_sqrtf        (arg as uint8)                                                                  as float        

  declare proc k_sqrtf        (arg as int8)                                                                    as float

  declare proc k_sqrtf        (arg as uint16)                                                                  as float        

  declare proc k_sqrtf        (arg as int16)                                                                  as float

  declare proc k_sqrtf        (arg as uint32)                                                                  as float        

  declare proc k_sqrtf        (arg as int32)                                                                  as float

  declare proc k_sqrtf        (arg as uint64)                                                                  as float        

  declare proc k_sqrtf        (arg as int64)                                                                  as float

  declare proc k_sqrtf        (arg as single)                                                                  as float        

  declare proc k_sqrtf        (arg as float)                                                                  as float



  declare def  k_memset        (de  as uint8    ptr, sz        as uint8      , v          as uint8)

  declare def  k_memset        (de  as int8    ptr, sz        as int8        , v          as int8)

  declare def  k_memset        (de  as uint16  ptr, sz        as uint16      , v          as uint16)

  declare def  k_memset        (de  as int16    ptr, sz        as int16      , v          as int16)

  declare def  k_memset        (de  as uint32  ptr, sz        as uint32      , v          as uint32)

  declare def  k_memset        (de  as int32    ptr, sz        as int32      , v          as int32)        

  declare def  k_memset        (de  as uint64  ptr, sz        as uint64      , v          as uint64)

  declare def  k_memset        (de  as int64    ptr, sz        as int64      , v          as int64)

  declare def  k_memset        (de  as single  ptr, sz        as single      , v          as single) 

  declare def  k_memset        (de  as float    ptr, sz        as float      , v          as float)  

  declare def  k_memset        (de  as FLOAT128 ptr, sz        as FLOAT128    , v          as FLOAT128)  

  declare def  k_memset        (de  as FLOAT256 ptr, sz        as FLOAT256    , v          as FLOAT256)  

  declare def  k_memset        (de  as FLOAT512 ptr, sz        as FLOAT512    , v          as FLOAT512)



  declare def  k_memset        (de  as uint8      , sz        as uint8      , v          as uint8)

  declare def  k_memset        (de  as int8        , sz        as int8        , v          as int8)

  declare def  k_memset        (de  as uint16      , sz        as uint16      , v          as uint16)

  declare def  k_memset        (de  as int16      , sz        as int16      , v          as int16)

  declare def  k_memset        (de  as uint32      , sz        as uint32      , v          as uint32)

  declare def  k_memset        (de  as int32      , sz        as int32      , v          as int32)        

  declare def  k_memset        (de  as uint64      , sz        as uint64      , v          as uint64)

  declare def  k_memset        (de  as int64      , sz        as int64      , v          as int64)

  declare def  k_memset        (de  as single      , sz        as single      , v          as single)  

  declare def  k_memset        (de  as float      , sz        as float      , v          as float)

  declare def  k_memset        (de  as FLOAT128    , sz        as FLOAT128    , v          as FLOAT128)  

  declare def  k_memset        (de  as FLOAT256    , sz        as FLOAT256    , v          as FLOAT256)  

  declare def  k_memset        (de  as FLOAT512    , sz        as FLOAT512    , v          as FLOAT512)



  declare def  k_memcpy        (su  as uint8  ptr  , de        as uint8  ptr  , sz        as uint8)

  declare def  k_memcpy        (su  as int8  ptr  , de        as int8  ptr  , sz        as int8)

  declare def  k_memcpy        (su  as uint16 ptr  , de        as uint16 ptr  , sz        as uint16)

  declare def  k_memcpy        (su  as int16  ptr  , de        as int16  ptr  , sz        as int16)

  declare def  k_memcpy        (su  as uint32 ptr  , de        as uint32 ptr  , sz        as uint32)

  declare def  k_memcpy        (su  as int32  ptr  , de        as int32  ptr  , sz        as int32)

  declare def  k_memcpy        (su  as uint64 ptr  , de        as uint64 ptr  , sz        as uint64)

  declare def  k_memcpy        (su  as int64  ptr  , de        as int64  ptr  , sz        as int64)

  declare def  k_memcpy        (su  as single ptr  , de        as single ptr  , sz        as single)

  declare def  k_memcpy        (su  as float  ptr  , de        as float  ptr  , sz        as float)

  declare def  k_memcpy        (su  as FLOAT128 ptr, de        as FLOAT128 ptr, sz        as FLOAT128)

  declare def  k_memcpy        (su  as FLOAT256 ptr, de        as FLOAT256 ptr, sz        as FLOAT256)  

  declare def  k_memcpy        (su  as FLOAT512 ptr, de        as FLOAT512 ptr, sz        as FLOAT512) 



  declare def  k_memcpy        (su  as uint8      , de        as uint8      , sz        as uint8)

  declare def  k_memcpy        (su  as int8        , de        as int8        , sz        as int8)

  declare def  k_memcpy        (su  as uint16      , de        as uint16      , sz        as uint16)

  declare def  k_memcpy        (su  as int16      , de        as int16      , sz        as int16)

  declare def  k_memcpy        (su  as uint32      , de        as uint32      , sz        as uint32)

  declare def  k_memcpy        (su  as int32      , de        as int32      , sz        as int32)

  declare def  k_memcpy        (su  as uint64      , de        as uint64      , sz        as uint64)

  declare def  k_memcpy        (su  as int64      , de        as int64      , sz        as int64)

  declare def  k_memcpy        (su  as single      , de        as single      , sz        as single)

  declare def  k_memcpy        (su  as float      , de        as float      , sz        as float)

  declare def  k_memcpy        (su  as FLOAT128    , de        as FLOAT128    , sz        as FLOAT128)

  declare def  k_memcpy        (su  as FLOAT256    , de        as FLOAT256    , sz        as FLOAT256)    

  declare def  k_memcpy        (su  as FLOAT512    , de        as FLOAT512    , sz        as FLOAT512)



  declare proc k_minf          (v1  as uint8      , v2        as uint8)                                      as float  

  declare proc k_minf          (v1  as int8        , v2        as int8)                                        as float 

  declare proc k_minf          (v1  as uint16      , v2        as uint16)                                      as float  

  declare proc k_minf          (v1  as int16      , v2        as int16)                                      as float 

  declare proc k_minf          (v1  as uint32      , v2        as uint32)                                      as float  

  declare proc k_minf          (v1  as int32      , v2        as int32)                                      as float  

  declare proc k_minf          (v1  as uint64      , v2        as uint64)                                      as float  

  declare proc k_minf          (v1  as int64      , v2        as int64)                                      as float 

  declare proc k_minf          (v1  as single      , v2        as single)                                      as float  

  declare proc k_minf          (v1  as float      , v2        as float)                                      as float

  declare proc k_minf          (v1  as FLOAT128    , v2        as FLOAT128)                                    as float

  declare proc k_minf          (v1  as FLOAT256    , v2        as FLOAT256)                                    as float

  declare proc k_minf          (v1  as FLOAT512    , v2        as FLOAT512)                                    as float    



  declare proc k_maxf          (v1  as uint8      , v2        as uint8)                                      as float  

  declare proc k_maxf          (v1  as int8        , v2        as int8)                                        as float

  declare proc k_maxf          (v1  as uint16      , v2        as uint16)                                      as float  

  declare proc k_maxf          (v1  as int16      , v2        as int16)                                      as float

  declare proc k_maxf          (v1  as uint32      , v2        as uint32)                                      as float  

  declare proc k_maxf          (v1  as int32      , v2        as int32)                                      as float

  declare proc k_maxf          (v1  as uint64      , v2        as uint64)                                      as float  

  declare proc k_maxf          (v1  as int64      , v2        as int64)                                      as float

  declare proc k_maxf          (v1  as single      , v2        as single)                                      as float  

  declare proc k_maxf          (v1  as float      , v2        as float)                                      as float

  declare proc k_maxf          (v1  as FLOAT128    , v2        as FLOAT128)                                    as float  

  declare proc k_maxf          (v1  as FLOAT256    , v2        as FLOAT256)                                    as float

  declare proc k_maxf          (v1  as FLOAT512    , v2        as FLOAT512)                                    as float  

    

  declare proc k_strlen        (s  as uchar ptr)                                                              as SYSTEM_TYPE

  declare proc k_strtrim      (s  as uchar ptr)                                                              as uchar ptr

  declare proc k_strcontains  (s  as uchar ptr  , s2        as uchar ptr)                                  as SYSTEM_TYPE

  declare proc k_strindexof    (s  as uchar ptr  , s2        as uchar ptr)                                  as SYSTEM_TYPE

  declare proc k_strlastindexof(s  as uchar ptr  , s2        as uchar ptr)                                  as SYSTEM_TYPE

  declare proc k_strncmp      (s1  as uchar ptr  , s2        as uchar ptr  , count      as SYSTEM_TYPE)    as SYSTEM_TYPE

  declare proc k_strcmp        (s1  as uchar ptr  , s2        as uchar ptr)                                  as SYSTEM_TYPE

  declare def  k_strrev        (s  as uchar ptr)

  declare proc k_strtoupper    (s  as uchar ptr)                                                              as uchar ptr

  declare proc k_strtolower    (s  as uchar ptr)                                                              as uchar ptr

  declare proc k_substring    (s  as uchar ptr  , index      as SYSTEM_TYPE , count      as SYSTEM_TYPE)    as uchar ptr

  declare proc k_strendswith  (src as uchar ptr  , search    as uchar ptr)                                  as SYSTEM_TYPE

  declare proc k_strcat        (s1  as uchar ptr  , s2        as uchar ptr)                                  as uchar ptr



  declare proc k_clampf        (x  as uint8      , lowerlimit as uint8      , upperlimit as uint8)          as float 

  declare proc k_clampf        (x  as int8        , lowerlimit as int8        , upperlimit as int8)            as float

  declare proc k_clampf        (x  as uint16      , lowerlimit as uint16      , upperlimit as uint16)          as float 

  declare proc k_clampf        (x  as int16      , lowerlimit as int16      , upperlimit as int16)          as float

  declare proc k_clampf        (x  as uint32      , lowerlimit as uint32      , upperlimit as uint32)          as float 

  declare proc k_clampf        (x  as int32      , lowerlimit as int32      , upperlimit as int32)          as float

  declare proc k_clampf        (x  as uint64      , lowerlimit as uint64      , upperlimit as uint64)          as float 

  declare proc k_clampf        (x  as int64      , lowerlimit as int64      , upperlimit as int64)          as float  

  declare proc k_clampf        (x  as single      , lowerlimit as single      , upperlimit as single)          as float 

  declare proc k_clampf        (x  as float      , lowerlimit as float      , upperlimit as float)          as float

  declare proc k_clampf        (x  as FLOAT128    , lowerlimit as FLOAT128    , upperlimit as FLOAT128)        as float  

  declare proc k_clampf        (x  as FLOAT256    , lowerlimit as FLOAT256    , upperlimit as FLOAT256)        as float  

  declare proc k_clampf        (x  as FLOAT512    , lowerlimit as FLOAT512    , upperlimit as FLOAT512)        as float  

    

  ' kernel mode OpenGL shader language

  declare proc k_radiance            (      deg  as      uint8)                                                  as float  

  declare proc k_radiance            (      deg  as      int8)                                                  as float  

  declare proc k_radiance            (      deg  as      uint16)                                                as float  

  declare proc k_radiance            (      deg  as      int16)                                                  as float  

  declare proc k_radiance            (      deg  as      uint32)                                                as float  

  declare proc k_radiance            (      deg  as      int32)                                                  as float 

  declare proc k_radiance            (      deg  as      uint64)                                                as float  

  declare proc k_radiance            (      deg  as      int64)                                                  as float 

  declare proc k_radiance            (      deg  as      single)                                                as float  

  declare proc k_radiance    overload (      deg  as      float)                                                  as float 

  declare proc k_radiance            (byref v    as      vector2)                                                as vector2

  declare proc k_radiance            (byref v    as      vector3)                                                as vector3

  declare proc k_radiance            (byref v    as      vector4)                                                as vector4  



  declare proc k_degrees              (      rad  as      uint8)                                                  as float

  declare proc k_degrees              (      rad  as      int8)                                                  as float

  declare proc k_degrees              (      rad  as      uint16)                                                as float

  declare proc k_degrees              (      rad  as      int16)                                                  as float

  declare proc k_degrees              (      rad  as      uint32)                                                as float

  declare proc k_degrees              (      rad  as      int32)                                                  as float

  declare proc k_degrees              (      rad  as      uint64)                                                as float

  declare proc k_degrees              (      rad  as      int64)                                                  as float

  declare proc k_degrees              (      rad  as      single)                                                as float

  declare proc k_degrees    overload (      rad  as      float)                                                  as float

  declare proc k_degrees              (      rad  as      FLOAT128)                                              as float

  declare proc k_degrees              (      rad  as      FLOAT256)                                              as float

  declare proc k_degrees              (      rad  as      FLOAT512)                                              as float      

  declare proc k_degrees              (byref v    as      vector2)                                                as vector2

  declare proc k_degrees              (byref v    as      vector3)                                                as vector3

  declare proc k_degrees              (byref v    as      vector4)                                                as vector4



  declare proc k_atan                (      x    as      uint8  ,      y    as uint8)                          as float

  declare proc k_atan                (      x    as      int8    ,      y    as int8)                          as float

  declare proc k_atan                (      x    as      uint16  ,      y    as uint16)                        as float

  declare proc k_atan                (      x    as      int16  ,      y    as int16)                          as float

  declare proc k_atan                (      x    as      uint32  ,      y    as uint32)                        as float

  declare proc k_atan                (      x    as      int32  ,      y    as int32)                          as float

  declare proc k_atan                (      x    as      uint64  ,      y    as uint64)                        as float

  declare proc k_atan                (      x    as      int64  ,      y    as int64)                          as float

  declare proc k_atan                (      x    as      single  ,      y    as single)                        as float

  declare proc k_atan        overload (      x    as      float  ,      y    as float)                          as float

  declare proc k_atan                (      x    as      FLOAT128,      y    as FLOAT128)                      as float

  declare proc k_atan                (      x    as      FLOAT256,      y    as FLOAT256)                      as float

  declare proc k_atan                (      x    as      FLOAT512,      y    as FLOAT512)                      as float      

  declare proc k_atan                (byref x    as      vector2 ,byref y    as vector2)                        as vector2

  declare proc k_atan                (byref x    as      vector3 ,byref y    as vector3)                        as vector3

  declare proc k_atan                (byref x    as      vector4 ,byref y    as vector4)                        as vector4



  declare proc k_pow                  (      a    as      uint8  ,      b    as uint8)                          as float

  declare proc k_pow                  (      a    as      int8    ,      b    as int8)                          as float

  declare proc k_pow                  (      a    as      uint16  ,      b    as uint16)                        as float

  declare proc k_pow                  (      a    as      int16  ,      b    as int16)                          as float

  declare proc k_pow                  (      a    as      uint32  ,      b    as uint32)                        as float

  declare proc k_pow                  (      a    as      int32  ,      b    as int32)                          as float

  declare proc k_pow                  (      a    as      uint64  ,      b    as uint64)                        as float

  declare proc k_pow                  (      a    as      int64  ,      b    as int64)                          as float

  declare proc k_pow                  (      a    as      single  ,      b    as single)                        as float

  declare proc k_pow        overload (      a    as      float  ,      b    as float)                          as float

  declare proc k_pow                  (      a    as      FLOAT128,      b    as FLOAT128)                      as float

  declare proc k_pow                  (      a    as      FLOAT256,      b    as FLOAT256)                      as float

  declare proc k_pow                  (      a    as      FLOAT512,      b    as FLOAT512)                      as float    

  declare proc k_pow                  (byref a    as      vector2 ,byref b    as vector2)                        as vector2

  declare proc k_pow                  (byref a    as      vector3 ,byref b    as vector3)                        as vector3

  declare proc k_pow                  (byref a    as      vector4 ,byref b    as vector4)                        as vector4



  declare proc k_exp2f                (      a    as      uint8)                                                  as float

  declare proc k_exp2f                (      a    as      int8)                                                  as float

  declare proc k_exp2f                (      a    as      uint16)                                                as float

  declare proc k_exp2f                (      a    as      int16)                                                  as float

  declare proc k_exp2f                (      a    as      uint32)                                                as float

  declare proc k_exp2f                (      a    as      int32)                                                  as float

  declare proc k_exp2f                (      a    as      uint64)                                                as float

  declare proc k_exp2f                (      a    as      int64)                                                  as float

  declare proc k_exp2f                (      a    as      single)                                                as float

  declare proc k_exp2f                (      a    as      float)                                                  as float

  declare proc k_exp2f                (      a    as      FLOAT128)                                              as float

  declare proc k_exp2f                (      a    as      FLOAT256)                                              as float

  declare proc k_exp2f                (      a    as      FLOAT512)                                              as float



  declare proc k_exp                  (      a    as      uint8)                                                  as float

  declare proc k_exp                  (      a    as      int8)                                                  as float

  declare proc k_exp                  (      a    as      uint16)                                                as float

  declare proc k_exp                  (      a    as      int16)                                                  as float

  declare proc k_exp                  (      a    as      uint32)                                                as float

  declare proc k_exp                  (      a    as      int32)                                                  as float

  declare proc k_exp                  (      a    as      uint64)                                                as float

  declare proc k_exp                  (      a    as      int64)                                                  as float

  declare proc k_exp                  (      a    as      single)                                                as float

  declare proc k_exp        overload (      a    as      float)                                                  as float

  declare proc k_exp                  (      a    as      FLOAT128)                                              as float

  declare proc k_exp                  (      a    as      FLOAT256)                                              as float

  declare proc k_exp                  (      a    as      FLOAT512)                                              as float    

  declare proc k_exp                  (byref a    as      vector2)                                                as vector2

  declare proc k_exp                  (byref a    as      vector3)                                                as vector3

  declare proc k_exp                  (byref a    as      vector4)                                                as vector4



  declare proc k_log                  (      a    as      uint8)                                                  as float

  declare proc k_log                  (      a    as      int8)                                                  as float

  declare proc k_log                  (      a    as      uint16)                                                as float

  declare proc k_log                  (      a    as      int16)                                                  as float

  declare proc k_log                  (      a    as      uint32)                                                as float

  declare proc k_log                  (      a    as      int32)                                                  as float

  declare proc k_log                  (      a    as      uint64)                                                as float

  declare proc k_log                  (      a    as      int64)                                                  as float

  declare proc k_log                  (      a    as      single)                                                as float

  declare proc k_log        overload (      a    as      float)                                                  as float

  declare proc k_log                  (      a    as      FLOAT128)                                              as float

  declare proc k_log                  (      a    as      FLOAT256)                                              as float

  declare proc k_log                  (      a    as      FLOAT512)                                              as float

  declare proc k_log                  (byref a    as      vector2)                                                as vector2

  declare proc k_log                  (byref a    as      vector3)                                                as vector3

  declare proc k_log                  (byref a    as      vector4)                                                as vector4



  declare proc k_exp2                (byref a    as      uint8)                                                  as float

  declare proc k_exp2                (byref a    as      int8)                                                  as float

  declare proc k_exp2                (byref a    as      uint16)                                                as float

  declare proc k_exp2                (byref a    as      int16)                                                  as float

  declare proc k_exp2                (byref a    as      uint32)                                                as float

  declare proc k_exp2                (byref a    as      int32)                                                  as float

  declare proc k_exp2                (byref a    as      uint64)                                                as float

  declare proc k_exp2                (byref a    as      int64)                                                  as float

  declare proc k_exp2                (byref a    as      single)                                                as float

  declare proc k_exp2        overload (byref a    as      float)                                                  as float

  declare proc k_exp2                (byref a    as      FLOAT128)                                              as float

  declare proc k_exp2                (byref a    as      FLOAT256)                                              as float

  declare proc k_exp2                (byref a    as      FLOAT512)                                              as float

  declare proc k_exp2                (byref a    as      vector2)                                                as vector2

  declare proc k_exp2                (byref a    as      vector3)                                                as vector3

  declare proc k_exp2                (byref a    as      vector4)                                                as vector4



  declare proc k_log2                (      a    as      uint8)                                                  as float

  declare proc k_log2                (      a    as      int8)                                                  as float

  declare proc k_log2                (      a    as      uint16)                                                as float

  declare proc k_log2                (      a    as      int16)                                                  as float

  declare proc k_log2                (      a    as      uint32)                                                as float

  declare proc k_log2                (      a    as      int32)                                                  as float

  declare proc k_log2                (      a    as      uint64)                                                as float

  declare proc k_log2                (      a    as      int64)                                                  as float

  declare proc k_log2                (      a    as      single)                                                as float

  declare proc k_log2        overload (      a    as      float)                                                  as float

  declare proc k_log2                (      a    as      FLOAT128)                                              as float

  declare proc k_log2                (      a    as      FLOAT256)                                              as float

  declare proc k_log2                (      a    as      FLOAT512)                                              as float

  declare proc k_log2                (byref a    as      vector2)                                                as vector2

  declare proc k_log2                (byref a    as      vector3)                                                as vector3

  declare proc k_log2                (byref a    as      vector4)                                                as vector4



  declare proc k_sqrt                (      a    as      uint8)                                                  as float

  declare proc k_sqrt                (      a    as      int8)                                                  as float

  declare proc k_sqrt                (      a    as      uint16)                                                as float

  declare proc k_sqrt                (      a    as      int16)                                                  as float

  declare proc k_sqrt                (      a    as      uint32)                                                as float

  declare proc k_sqrt                (      a    as      int32)                                                  as float

  declare proc k_sqrt                (      a    as      uint64)                                                as float

  declare proc k_sqrt                (      a    as      int64)                                                  as float

  declare proc k_sqrt                (      a    as      single)                                                as float

  declare proc k_sqrt        overload (      a    as      float)                                                  as float

  declare proc k_sqrt                (      a    as      FLOAT128)                                              as float

  declare proc k_sqrt                (      a    as      FLOAT256)                                              as float

  declare proc k_sqrt                (      a    as      FLOAT512)                                              as float

  declare proc k_sqrt                (byref a    as      vector2)                                                as vector2

  declare proc k_sqrt                (byref a    as      vector3)                                                as vector3

  declare proc k_sqrt                (byref a    as      vector4)                                                as vector4



  declare proc k_inversesqrt          (      a    as      uint8)                                                  as float

  declare proc k_inversesqrt          (      a    as      int8)                                                  as float

  declare proc k_inversesqrt          (      a    as      uint16)                                                as float

  declare proc k_inversesqrt          (      a    as      int16)                                                  as float

  declare proc k_inversesqrt          (      a    as      uint32)                                                as float

  declare proc k_inversesqrt          (      a    as      int32)                                                  as float

  declare proc k_inversesqrt          (      a    as      uint64)                                                as float

  declare proc k_inversesqrt          (      a    as      int64)                                                  as float

  declare proc k_inversesqrt          (      a    as      single)                                                as float

  declare proc k_inversesqrt overload (      a    as      float)                                                  as float

  declare proc k_inversesqrt          (      a    as      FLOAT128)                                              as float

  declare proc k_inversesqrt          (      a    as      FLOAT256)                                              as float

  declare proc k_inversesqrt          (      a    as      FLOAT512)                                              as float

  declare proc k_inversesqrt          (byref a    as      vector2)                                                as vector2

  declare proc k_inversesqrt          (byref a    as      vector3)                                                as vector3

  declare proc k_inversesqrt          (byref a    as      vector4)                                                as vector4



  declare proc k_sign                (      a    as      uint8)                                                  as float

  declare proc k_sign                (      a    as      int8)                                                  as float

  declare proc k_sign                (      a    as      uint16)                                                as float

  declare proc k_sign                (      a    as      int16)                                                  as float

  declare proc k_sign                (      a    as      uint32)                                                as float

  declare proc k_sign                (      a    as      int32)                                                  as float

  declare proc k_sign                (      a    as      uint64)                                                as float

  declare proc k_sign                (      a    as      int64)                                                  as float

  declare proc k_sign                (      a    as      single)                                                as float

  declare proc k_sign        overload (      a    as      float)                                                  as float

  declare proc k_sign                (      a    as      FLOAT128)                                              as float

  declare proc k_sign                (      a    as      FLOAT256)                                              as float

  declare proc k_sign                (      a    as      FLOAT512)                                              as float    

  declare proc k_sign                (byref a    as      vector2)                                                as vector2

  declare proc k_sign                (byref a    as      vector3)                                                as vector3

  declare proc k_sign                (byref a    as      vector4)                                                as vector4



  declare proc k_floor                (      a    as      uint8)                                                  as float

  declare proc k_floor                (      a    as      int8)                                                  as float

  declare proc k_floor                (      a    as      uint16)                                                as float

  declare proc k_floor                (      a    as      int16)                                                  as float

  declare proc k_floor                (      a    as      uint32)                                                as float

  declare proc k_floor                (      a    as      int32)                                                  as float

  declare proc k_floor                (      a    as      uint64)                                                as float

  declare proc k_floor                (      a    as      int64)                                                  as float

  declare proc k_floor                (      a    as      single)                                                as float

  declare proc k_floor      overload (      a    as      float)                                                  as float

  declare proc k_floor                (      a    as      FLOAT128)                                              as float

  declare proc k_floor                (      a    as      FLOAT256)                                              as float

  declare proc k_floor                (      a    as      FLOAT512)                                              as float  

  declare proc k_floor                (byref a    as      vector2)                                                as vector2

  declare proc k_floor                (byref a    as      vector3)                                                as vector3

  declare proc k_floor                (byref a    as      vector4)                                                as vector4



  declare proc k_ceil                (      a    as      uint8)                                                  as float

  declare proc k_ceil                (      a    as      int8)                                                  as float

  declare proc k_ceil                (      a    as      uint16)                                                as float

  declare proc k_ceil                (      a    as      int16)                                                  as float

  declare proc k_ceil                (      a    as      uint32)                                                as float

  declare proc k_ceil                (      a    as      int32)                                                  as float

  declare proc k_ceil                (      a    as      uint64)                                                as float

  declare proc k_ceil                (      a    as      int64)                                                  as float

  declare proc k_ceil                (      a    as      single)                                                as float

  declare proc k_ceil        overload (      a    as      float)                                                  as float

  declare proc k_ceil                (      a    as      FLOAT128)                                              as float

  declare proc k_ceil                (      a    as      FLOAT256)                                              as float

  declare proc k_ceil                (      a    as      FLOAT512)                                              as float

  declare proc k_ceil                (byref a    as      vector2)                                                as vector2

  declare proc k_ceil                (byref a    as      vector3)                                                as vector3

  declare proc k_ceil                (byref a    as      vector4)                                                as vector4



  declare proc k_fract                (      x    as      uint8)                                                  as float

  declare proc k_fract                (      x    as      int8)                                                  as float

  declare proc k_fract                (      x    as      uint16)                                                as float

  declare proc k_fract                (      x    as      int16)                                                  as float  

  declare proc k_fract                (      x    as      uint32)                                                as float

  declare proc k_fract                (      x    as      int32)                                                  as float

  declare proc k_fract                (      x    as      uint64)                                                as float

  declare proc k_fract                (      x    as      int64)                                                  as float

  declare proc k_fract                (      x    as      single)                                                as float

  declare proc k_fract      overload (      x    as      float)                                                  as float

  declare proc k_fract                (      x    as      FLOAT128)                                              as float

  declare proc k_fract                (      x    as      FLOAT256)                                              as float

  declare proc k_fract                (      x    as      FLOAT512)                                              as float

  declare proc k_fract                (byref x    as      vector2)                                                as vector2

  declare proc k_fract                (byref x    as      vector3)                                                as vector3

  declare proc k_fract                (byref x    as      vector4)                                                as vector4



  declare proc k_modulo              (      x    as      uint8  ,      y    as uint8)                          as float

  declare proc k_modulo              (      x    as      int8    ,      y    as int8)                          as float

  declare proc k_modulo              (      x    as      uint16  ,      y    as uint16)                        as float

  declare proc k_modulo              (      x    as      int16  ,      y    as int16)                          as float

  declare proc k_modulo              (      x    as      uint32  ,      y    as uint32)                        as float

  declare proc k_modulo              (      x    as      int32  ,      y    as int32)                          as float

  declare proc k_modulo              (      x    as      uint64  ,      y    as uint64)                        as float

  declare proc k_modulo      overload (      x    as      int64  ,      y    as int64)                          as float

  declare proc k_modulo              (      x    as      single  ,      y    as single)                        as float  

  declare proc k_modulo              (      x    as      float  ,      y    as float)                          as float

  declare proc k_modulo              (      x    as      FLOAT128,      y    as FLOAT128)                      as float

  declare proc k_modulo              (      x    as      FLOAT256,      y    as FLOAT256)                      as float

  declare proc k_modulo              (      x    as      FLOAT512,      y    as FLOAT512)                      as float

  declare proc k_modulo              (byref x    as      vector2 ,byref y    as vector2)                        as vector2

  declare proc k_modulo              (byref x    as      vector3 ,byref y    as vector3)                        as vector3

  declare proc k_modulo              (byref x    as      vector4 ,byref y    as vector4)                        as vector4



  declare proc k_min                  (      a    as      uint8  ,      b    as uint8)                          as float 

  declare proc k_min                  (      a    as      int8    ,      b    as int8)                          as float 

  declare proc k_min                  (      a    as      uint16  ,      b    as uint16)                        as float 

  declare proc k_min                  (      a    as      int16  ,      b    as int16)                          as float 

  declare proc k_min                  (      a    as      uint32  ,      b    as uint32)                        as float 

  declare proc k_min                  (      a    as      int32  ,      b    as int32)                          as float 

  declare proc k_min                  (      a    as      uint64  ,      b    as uint64)                        as float 

  declare proc k_min                  (      a    as      int64  ,      b    as int64)                          as float 

  declare proc k_min                  (      a    as      single  ,      b    as single)                        as float 

  declare proc k_min        overload (      a    as      float  ,      b    as float)                          as float    

  declare proc k_min                  (byref a    as      FLOAT128,byref b    as FLOAT128)                      as float 

  declare proc k_min                  (byref a    as      FLOAT256,byref b    as FLOAT256)                      as float 

  declare proc k_min                  (byref a    as      FLOAT512,byref b    as FLOAT512)                      as float

  declare proc k_min                  (byref a    as      vector2 ,byref b    as vector2)                        as vector2

  declare proc k_min                  (byref a    as      vector3 ,byref b    as vector3)                        as vector3

  declare proc k_min                  (byref a    as      vector4 ,byref b    as vector4)                        as vector4

  declare proc k_min                  (byref a    as      vector2 ,byref b    as float)                          as vector2

  declare proc k_min                  (byref a    as      vector3 ,byref b    as float)                          as vector3

  declare proc k_min                  (byref a    as      vector4 ,byref b    as float)                          as vector4



  declare proc k_max                  (      a    as      uint8  ,      b    as uint8)                          as float 

  declare proc k_max                  (      a    as      int8    ,      b    as int8)                          as float 

  declare proc k_max                  (      a    as      uint16  ,      b    as uint16)                        as float 

  declare proc k_max                  (      a    as      int16  ,      b    as int16)                          as float 

  declare proc k_max                  (      a    as      uint32  ,      b    as uint32)                        as float 

  declare proc k_max                  (      a    as      int32  ,      b    as int32)                          as float 

  declare proc k_max                  (      a    as      uint64  ,      b    as uint64)                        as float 

  declare proc k_max                  (      a    as      int64  ,      b    as int64)                          as float 

  declare proc k_max                  (      a    as      single  ,      b    as single)                        as float

  declare proc k_max        overload (      a    as      float  ,      b    as float)                          as float

  declare proc k_max                  (byref a    as      FLOAT128,byref b    as FLOAT128)                      as float 

  declare proc k_max                  (byref a    as      FLOAT256,byref b    as FLOAT256)                      as float 

  declare proc k_max                  (byref a    as      FLOAT512,byref b    as FLOAT512)                      as float

  declare proc k_max                  (byref a    as      vector2 ,byref b    as vector2)                        as vector2

  declare proc k_max                  (byref a    as      vector3 ,byref b    as vector3)                        as vector3

  declare proc k_max                  (byref a    as      vector4 ,byref b    as vector4)                        as vector4

  declare proc k_max                  (byref a    as      vector2 ,byref b    as float)                          as vector2

  declare proc k_max                  (byref a    as      vector3 ,byref b    as float)                          as vector3

  declare proc k_max                  (byref a    as      vector4 ,byref b    as float)                          as vector4



  declare proc k_pascalTriangle      (      a    as      uint8  ,      b    as uint8)                          as float

  declare proc k_pascalTriangle      (      a    as      int8    ,      b    as int8)                          as float

  declare proc k_pascalTriangle      (      a    as      uint16  ,      b    as uint16)                        as float

  declare proc k_pascalTriangle      (      a    as      int16  ,      b    as int16)                          as float

  declare proc k_pascalTriangle      (      a    as      uint32  ,      b    as uint32)                        as float

  declare proc k_pascalTriangle      (      a    as      int32  ,      b    as int32)                          as float

  declare proc k_pascalTriangle      (      a    as      uint64  ,      b    as uint64)                        as float

  declare proc k_pascalTriangle      (      a    as      int64  ,      b    as int64)                          as float

  declare proc k_pascalTriangle      (      a    as      single  ,      b    as single)                        as float

  declare proc k_pascalTriangle      (      a    as      float  ,      b    as float)                          as float



  declare proc k_clamp                (      a    as      uint8  ,      b    as uint8  ,      c    as uint8)  as float

  declare proc k_clamp                (      a    as      int8    ,      b    as int8    ,      c    as int8)    as float 

  declare proc k_clamp                (      a    as      uint16  ,      b    as uint16  ,      c    as uint16)  as float

  declare proc k_clamp                (      a    as      int16  ,      b    as int16  ,      c    as int16)  as float 

  declare proc k_clamp                (      a    as      uint32  ,      b    as uint32  ,      c    as uint32)  as float

  declare proc k_clamp                (      a    as      int32  ,      b    as int32  ,      c    as int32)  as float 

  declare proc k_clamp                (      a    as      uint64  ,      b    as uint64  ,      c    as uint64)  as float

  declare proc k_clamp                (      a    as      int64  ,      b    as int64  ,      c    as int64)  as float 

  declare proc k_clamp                (      a    as      single  ,      b    as single  ,      c    as single)  as float  

  declare proc k_clamp      overload (      a    as      float  ,      b    as float  ,      c    as float)  as float

  declare proc k_clamp                (byref a    as      FLOAT128,byref b    as FLOAT128,byref c    as FLOAT128)as float  

  declare proc k_clamp                (byref a    as      FLOAT256,byref b    as FLOAT256,byref c    as FLOAT256)as float

  declare proc k_clamp                (byref a    as      FLOAT512,byref b    as FLOAT512,byref c    as FLOAT512)as float  

  declare proc k_clamp                (byref a    as      vector2 ,byref b    as vector2 ,byref c    as vector2) as vector2

  declare proc k_clamp                (byref a    as      vector3 ,byref b    as vector3 ,byref c    as vector3) as vector3

  declare proc k_clamp                (byref a    as      vector4 ,byref b    as vector4 ,byref c    as vector4) as vector4

  declare proc k_clamp                (byref a    as      vector2 ,      b    as float  ,      c    as float)  as vector2

  declare proc k_clamp                (byref a    as      vector3 ,      b    as float  ,      c    as float)  as vector3

  declare proc k_clamp                (byref a    as      vector4 ,      b    as float  ,      c    as float)  as vector4



  declare proc k_generalSmoothStep    (      N    as      uint8  ,      x    as uint8)                          as float

  declare proc k_generalSmoothStep    (      N    as      int8    ,      x    as int8)                          as float

  declare proc k_generalSmoothStep    (      N    as      uint16  ,      x    as uint16)                        as float

  declare proc k_generalSmoothStep    (      N    as      int16  ,      x    as int16)                          as float

  declare proc k_generalSmoothStep    (      N    as      uint32  ,      x    as uint32)                        as float

  declare proc k_generalSmoothStep    (      N    as      int32  ,      x    as int32)                          as float

  declare proc k_generalSmoothStep    (      N    as      uint64  ,      x    as uint64)                        as float

  declare proc k_generalSmoothStep    (      N    as      int64  ,      x    as int64)                          as float

  declare proc k_generalSmoothStep    (      N    as      single  ,      x    as single)                        as float

  declare proc k_generalSmoothStep    (      N    as      float  ,      x    as float)                          as float



  declare proc k_mix                  (      a    as      uint8  ,      b    as uint8  ,      c    as uint8)  as float

  declare proc k_mix                  (      a    as      int8    ,      b    as int8    ,      c    as int8)    as float

  declare proc k_mix                  (      a    as      uint16  ,      b    as uint16  ,      c    as uint16)  as float

  declare proc k_mix                  (      a    as      int16  ,      b    as int16  ,      c    as int16)  as float

  declare proc k_mix                  (      a    as      uint32  ,      b    as uint32  ,      c    as uint32)  as float

  declare proc k_mix                  (      a    as      int32  ,      b    as int32  ,      c    as int32)  as float  

  declare proc k_mix                  (      a    as      uint64  ,      b    as uint64  ,      c    as uint64)  as float

  declare proc k_mix                  (      a    as      int64  ,      b    as int64  ,      c    as int64)  as float

  declare proc k_mix                  (      a    as      single  ,      b    as single  ,    c    as single)  as float

  declare proc k_mix        overload (      a    as      float  ,      b    as float  ,      c    as float)  as float

  declare proc k_mix                  (      a    as      FLOAT128,      b    as FLOAT128,      c    as FLOAT128)as float

  declare proc k_mix                  (      a    as      FLOAT256,      b    as FLOAT256,      c    as FLOAT256)as float

  declare proc k_mix                  (      a    as      FLOAT512,      b    as FLOAT512,      c    as FLOAT512)as float

  declare proc k_mix                  (byref a    as      vector2 ,byref b    as vector2 ,byref c    as vector2) as vector2

  declare proc k_mix                  (byref a    as      vector3 ,byref b    as vector3 ,byref c    as vector3) as vector3

  declare proc k_mix                  (byref a    as      vector4 ,byref b    as vector4 ,byref c    as vector4) as vector4

  declare proc k_mix                  (byref a    as      vector2 ,byref b    as vector2 ,      c    as float)  as vector2

  declare proc k_mix                  (byref a    as      vector3 ,byref b    as vector3 ,      c    as float)  as vector3

  declare proc k_mix                  (byref a    as      vector4 ,byref b    as vector4 ,      c    as float)  as vector4



  declare proc k_step                (      edge  as      uint8  ,      x    as uint8)                          as float

  declare proc k_step                (      edge  as      int8    ,      x    as int8)                          as float

  declare proc k_step                (      edge  as      uint16  ,      x    as uint16)                        as float

  declare proc k_step                (      edge  as      int16  ,      x    as int16)                          as float

  declare proc k_step                (      edge  as      uint32  ,      x    as uint32)                        as float

  declare proc k_step                (      edge  as      int32  ,      x    as int32)                          as float

  declare proc k_step                (      edge  as      uint64  ,      x    as uint64)                        as float

  declare proc k_step                (      edge  as      int64  ,      x    as int64)                          as float

  declare proc k_step                (      edge  as      single  ,      x    as single)                        as float

  declare proc k_step        overload (      edge  as      float  ,      x    as float)                          as float

  declare proc k_step                (      edge  as      FLOAT128,      x    as FLOAT128)                      as float

  declare proc k_step                (      edge  as      FLOAT256,      x    as FLOAT256)                      as float

  declare proc k_step                (      edge  as      FLOAT512,      x    as FLOAT512)                      as float  

  declare proc k_step                (byref edge  as      vector2 ,byref x    as vector2)                        as vector2

  declare proc k_step                (byref edge  as      vector3 ,byref x    as vector3)                        as vector3

  declare proc k_step                (byref edge  as      vector4 ,byref x    as vector4)                        as vector4

  declare proc k_step                (      edge  as      float  ,byref x    as vector2)                        as vector2

  declare proc k_step                (      edge  as      float  ,byref x    as vector3)                        as vector3

  declare proc k_step                (      edge  as      float  ,byref x    as vector4)                        as vector4



  declare proc k_smoothstep          (      edge0 as      uint8  ,      edge1 as uint8  ,      x    as uint8)  as float

  declare proc k_smoothstep          (      edge0 as      int8    ,      edge1 as int8    ,      x    as int8)    as float

  declare proc k_smoothstep          (      edge0 as      uint16  ,      edge1 as uint16  ,      x    as uint16)  as float

  declare proc k_smoothstep          (      edge0 as      int16  ,      edge1 as int16  ,      x    as int16)  as float

  declare proc k_smoothstep          (      edge0 as      uint32  ,      edge1 as uint32  ,      x    as uint32)  as float

  declare proc k_smoothstep          (      edge0 as      int32  ,      edge1 as int32  ,      x    as int32)  as float

  declare proc k_smoothstep          (      edge0 as      uint64  ,      edge1 as uint64  ,      x    as uint64)  as float

  declare proc k_smoothstep          (      edge0 as      int64  ,      edge1 as int64  ,      x    as int64)  as float

  declare proc k_smoothstep          (      edge0 as      single  ,      edge1 as single  ,      x    as single)  as float

  declare proc k_smoothstep  overload (      edge0 as      float  ,      edge1 as float  ,      x    as float)  as float

  declare proc k_smoothstep          (      edge0 as      FLOAT128,      edge1 as FLOAT128,      x    as FLOAT128)as float

  declare proc k_smoothstep          (      edge0 as      FLOAT256,      edge1 as FLOAT256,      x    as FLOAT256)as float

  declare proc k_smoothstep          (      edge0 as      FLOAT512,      edge1 as FLOAT512,      x    as FLOAT512)as float



  declare proc k_smootherstep        (      edge0 as      uint8  ,      edge1 as uint8 ,        x    as uint8)  as float      

  declare proc k_smootherstep        (      edge0 as      int8    ,      edge1 as int8  ,        x    as int8)    as float

  declare proc k_smootherstep        (      edge0 as      uint16  ,      edge1 as uint16,        x    as uint16)  as float      

  declare proc k_smootherstep        (      edge0 as      int16  ,      edge1 as int16 ,        x    as int16)  as float

  declare proc k_smootherstep        (      edge0 as      uint32  ,      edge1 as uint32,        x    as uint32)  as float      

  declare proc k_smootherstep        (      edge0 as      int32  ,      edge1 as int32 ,        x    as int32)  as float

  declare proc k_smootherstep        (      edge0 as      uint64  ,      edge1 as uint64,        x    as uint64)  as float      

  declare proc k_smootherstep        (      edge0 as      int64  ,      edge1 as int64 ,        x    as int64)  as float

  declare proc k_smootherstep        (      edge0 as      single  ,      edge1 as single,        x    as single)  as float      

  declare proc k_smootherstep        (      edge0 as      float  ,      edge1 as float,        x    as float)  as float



  declare proc k_smoothstep          (byref edge0 as      vector2 ,byref edge1 as vector2 ,byref x    as vector2) as vector2

  declare proc k_smoothstep          (byref edge0 as      vector3 ,byref edge1 as vector3 ,byref x    as vector3) as vector3

  declare proc k_smoothstep          (byref edge0 as      vector4 ,byref edge1 as vector4 ,byref x    as vector4) as vector4

  declare proc k_smoothstep          (      edge0 as      float  ,      edge1 as float  ,byref x    as vector2) as vector2

  declare proc k_smoothstep          (      edge0 as      float  ,      edge1 as float  ,byref x    as vector3) as vector3

  declare proc k_smoothstep          (      edge0 as      float  ,      edge1 as float  ,byref x    as vector4) as vector4



  declare proc k_inverse_smoothstep  (      x    as      uint8)                                                  as float

  declare proc k_inverse_smoothstep  (      x    as      int8)                                                  as float

  declare proc k_inverse_smoothstep  (      x    as      uint16)                                                as float

  declare proc k_inverse_smoothstep  (      x    as      int16)                                                  as float

  declare proc k_inverse_smoothstep  (      x    as      uint32)                                                as float

  declare proc k_inverse_smoothstep  (      x    as      int32)                                                  as float

  declare proc k_inverse_smoothstep  (      x    as      uint64)                                                as float

  declare proc k_inverse_smoothstep  (      x    as      int64)                                                  as float

  declare proc k_inverse_smoothstep  (      x    as      single)                                                as float

  declare proc k_inverse_smoothstep  (      x    as      float)                                                  as float



  declare proc k_length2              (      a    as const uint8)                                                  as float

  declare proc k_length2              (      a    as const int8)                                                  as float

  declare proc k_length2              (      a    as const uint16)                                                as float

  declare proc k_length2              (      a    as const int16)                                                  as float

  declare proc k_length2              (      a    as const uint32)                                                as float

  declare proc k_length2              (      a    as const int32)                                                  as float

  declare proc k_length2              (      a    as const uint64)                                                as float

  declare proc k_length2              (      a    as const int64)                                                  as float

  declare proc k_length2              (      a    as const single)                                                as float 

  declare proc k_length2    overload (      a    as const float)                                                  as float

  declare proc k_length2              (byref v    as const FLOAT128)                                              as float 

  declare proc k_length2              (byref v    as const FLOAT256)                                              as float

  declare proc k_length2              (byref v    as const FLOAT512)                                              as float    

  declare proc k_length2              (byref v    as const vector2)                                                as float

  declare proc k_length2              (byref v    as const vector3)                                                as float

  declare proc k_length2              (byref v    as const vector4)                                                as float



  declare proc k_length              (      a    as const uint8)                                                  as float

  declare proc k_length              (      a    as const int8)                                                  as float

  declare proc k_length              (      a    as const uint16)                                                as float

  declare proc k_length              (      a    as const int16)                                                  as float

  declare proc k_length              (      a    as const uint32)                                                as float

  declare proc k_length              (      a    as const int32)                                                  as float

  declare proc k_length              (      a    as const uint64)                                                as float

  declare proc k_length              (      a    as const int64)                                                  as float

  declare proc k_length              (      a    as const single)                                                as float

  declare proc k_length      overload (      a    as const float)                                                  as float

  declare proc k_length              (byref v    as const FLOAT128)                                              as float

  declare proc k_length              (byref v    as const FLOAT256)                                              as float

  declare proc k_length              (byref v    as const FLOAT512)                                              as float      

  declare proc k_length              (byref v    as const vector2)                                                as float

  declare proc k_length              (byref v    as const vector3)                                                as float

  declare proc k_length              (byref v    as const vector4)                                                as float



  declare proc k_distance            (      a    as      uint8  ,      b    as uint8)                          as float

  declare proc k_distance            (      a    as      int8    ,      b    as int8)                          as float

  declare proc k_distance            (      a    as      uint16  ,      b    as uint16)                        as float

  declare proc k_distance            (      a    as      int16  ,      b    as int16)                          as float

  declare proc k_distance            (      a    as      uint32  ,      b    as uint32)                        as float

  declare proc k_distance            (      a    as      int32  ,      b    as int32)                          as float

  declare proc k_distance            (      a    as      uint64  ,      b    as uint64)                        as float

  declare proc k_distance            (      a    as      int64  ,      b    as int64)                          as float

  declare proc k_distance            (      a    as      single  ,      b    as single)                        as float

  declare proc k_distance    overload (      a    as      float  ,      b    as float)                          as float

  declare proc k_distance            (byref a    as      FLOAT128,byref b    as FLOAT128)                      as float

  declare proc k_distance            (byref a    as      FLOAT256,byref b    as FLOAT256)                      as float

  declare proc k_distance            (byref a    as      FLOAT512,byref b    as FLOAT512)                      as float      

  declare proc k_distance            (byref a    as      vector2 ,byref b    as vector2)                        as float

  declare proc k_distance            (byref a    as      vector3 ,byref b    as vector3)                        as float

  declare proc k_distance            (byref a    as      vector4 ,byref b    as vector4)                        as float



  declare proc k_dot                  (      a    as      uint8  ,      b    as uint8)                          as float

  declare proc k_dot                  (      a    as      int8    ,      b    as int8)                          as float

  declare proc k_dot                  (      a    as      uint16  ,      b    as uint16)                        as float

  declare proc k_dot                  (      a    as      int16  ,      b    as int16)                          as float

  declare proc k_dot                  (      a    as      uint32  ,      b    as uint32)                        as float

  declare proc k_dot                  (      a    as      int32  ,      b    as int32)                          as float  

  declare proc k_dot                  (      a    as      uint64  ,      b    as uint64)                        as float

  declare proc k_dot                  (      a    as      int64  ,      b    as int64)                          as float

  declare proc k_dot                  (      a    as      single  ,      b    as single)                        as float

  declare proc k_dot        overload (      a    as      float  ,      b    as float)                          as float

  declare proc k_dot                  (byref a    as      FLOAT128,byref b    as FLOAT128)                      as float

  declare proc k_dot                  (byref a    as      FLOAT256,byref b    as FLOAT256)                      as float

  declare proc k_dot                  (byref a    as      FLOAT512,byref b    as FLOAT512)                      as float  

  declare proc k_dot                  (byref a    as      vector2 ,byref b    as vector2)                        as float

  declare proc k_dot                  (byref a    as      vector3 ,byref b    as vector3)                        as float

  declare proc k_dot                  (byref a    as      vector4 ,byref b    as vector4)                        as float



  declare proc k_cross                (byref a    as      vector3 ,byref b    as vector3)                        as vector3



  declare proc k_normalize            (      v    as      uint8)                                                  as float

  declare proc k_normalize            (      v    as      int8)                                                  as float

  declare proc k_normalize            (      v    as      uint16)                                                as float

  declare proc k_normalize            (      v    as      int16)                                                  as float

  declare proc k_normalize            (      v    as      uint32)                                                as float

  declare proc k_normalize            (      v    as      int32)                                                  as float

  declare proc k_normalize            (      v    as      uint64)                                                as float

  declare proc k_normalize            (      v    as      int64)                                                  as float

  declare proc k_normalize            (      v    as      single)                                                as float

  declare proc k_normalize  overload (      v    as      float)                                                  as float

  declare proc k_normalize            (byref v    as      FLOAT128)                                              as float

  declare proc k_normalize            (byref v    as      FLOAT256)                                              as float

  declare proc k_normalize            (byref v    as      FLOAT512)                                              as float      

  declare proc k_normalize            (byref v    as      vector2)                                                as vector2

  declare proc k_normalize            (byref v    as      vector3)                                                as vector3

  declare proc k_normalize            (byref v    as      vector4)                                                as vector4



  declare proc k_faceforward          (      N    as      uint8  ,      I    as uint8  ,      Nref as uint8)  as float

  declare proc k_faceforward          (      N    as      int8    ,      I    as int8    ,      Nref as int8)    as float

  declare proc k_faceforward          (      N    as      uint16  ,      I    as uint16  ,      Nref as uint16)  as float

  declare proc k_faceforward          (      N    as      int16  ,      I    as int16  ,      Nref as int16)  as float

  declare proc k_faceforward          (      N    as      uint32  ,      I    as uint32  ,      Nref as uint32)  as float

  declare proc k_faceforward          (      N    as      int32  ,      I    as int32  ,      Nref as int32)  as float

  declare proc k_faceforward          (      N    as      uint64  ,      I    as uint64  ,      Nref as uint64)  as float

  declare proc k_faceforward          (      N    as      int64  ,      I    as int64  ,      Nref as int64)  as float

  declare proc k_faceforward          (      N    as      single  ,      I    as single  ,      Nref as single)  as float

  declare proc k_faceforward overload (      N    as      float  ,      I    as float  ,      Nref as float)  as float

  declare proc k_faceforward          (byref N    as      FLOAT128,byref I    as FLOAT128,byref Nref as FLOAT128)as float

  declare proc k_faceforward          (byref N    as      FLOAT256,byref I    as FLOAT256,byref Nref as FLOAT256)as float

  declare proc k_faceforward          (byref N    as      FLOAT512,byref I    as FLOAT512,byref Nref as FLOAT512)as float  

  declare proc k_faceforward          (byref N    as      vector2 ,byref I    as vector2 ,byref Nref as vector2) as vector2

  declare proc k_faceforward          (byref N    as      vector3 ,byref I    as vector3 ,byref Nref as vector3) as vector3

  declare proc k_faceforward          (byref N    as      vector4 ,byref I    as vector4 ,byref Nref as vector4) as vector4



  declare proc k_reflect    overload (      I    as      float  ,      N    as float)                          as float

  declare proc k_reflect              (byref I    as      vector2 ,byref N    as vector2)                        as vector2

  declare proc k_reflect              (byref I    as      vector3 ,byref N    as vector3)                        as vector3

  declare proc k_reflect              (byref I    as      vector4 ,byref N    as vector4)                        as vector4



  declare proc k_refract    overload (byref I    as      vector2 ,byref N    as vector2 ,      eta  as float)  as vector2

  declare proc k_refract              (byref I    as      vector3 ,byref N    as vector3 ,      eta  as float)  as vector3

  declare proc k_refract              (      I    as      vector4 ,      N    as vector4 ,      eta  as float)  as vector4 



  ' kernel float128 math functions

  declare def  k_float128_abs        (a as FLOAT128 ptr, b as FLOAT128 ptr)

  declare def  k_float128_from_double(a as FLOAT128 ptr, b as float ptr)

  declare def  k_float128_to_double  (a as FLOAT128 ptr, b as float ptr)

  declare def  k_float128_add        (a as FLOAT128 ptr, b as FLOAT128 ptr , c as FLOAT128 ptr)

  declare def  k_float128_sub        (a as FLOAT128 ptr, b as FLOAT128 ptr , c as FLOAT128 ptr)

  declare def  k_float128_mul        (a as FLOAT128 ptr, b as FLOAT128 ptr , c as FLOAT128 ptr)

  declare def  k_float128_div        (a as FLOAT128 ptr, b as FLOAT128 ptr , c as FLOAT128 ptr)

  declare proc k_float128_cmp        (a as FLOAT128 ptr, b as FLOAT128 ptr)                    as int_t

  

  ' kernel float256 math functions

  declare def  k_float256_abs        (a as FLOAT256 ptr, b as FLOAT256 ptr)

  declare def  k_float256_from_double(a as FLOAT256 ptr, b as float ptr)

  declare def  k_float256_to_double  (a as FLOAT256 ptr, b as float ptr)

  declare def  k_float256_add        (a as FLOAT256 ptr, b as FLOAT256 ptr , c as FLOAT256 ptr)

  declare def  k_float256_sub        (a as FLOAT256 ptr, b as FLOAT256 ptr , c as FLOAT256 ptr)

  declare def  k_float256_mul        (a as FLOAT256 ptr, b as FLOAT256 ptr , c as FLOAT256 ptr)

  declare def  k_float256_div        (a as FLOAT256 ptr, b as FLOAT256 ptr , c as FLOAT256 ptr)

  declare proc k_float256_cmp        (a as FLOAT256 ptr, b as FLOAT256 ptr)                    as int_t



  ' kernel float512 math functions

  declare def  k_float512_abs        (a as FLOAT512 ptr, b as FLOAT512 ptr)

  declare def  k_float512_from_double(a as FLOAT512 ptr, b as float ptr)

  declare def  k_float512_to_double  (a as FLOAT512 ptr, b as float ptr)

  declare def  k_float512_add        (a as FLOAT512 ptr, b as FLOAT512 ptr , c as FLOAT512 ptr)

  declare def  k_float512_sub        (a as FLOAT512 ptr, b as FLOAT512 ptr , c as FLOAT512 ptr)

  declare def  k_float512_mul        (a as FLOAT512 ptr, b as FLOAT512 ptr , c as FLOAT512 ptr)

  declare def  k_float512_div        (a as FLOAT512 ptr, b as FLOAT512 ptr , c as FLOAT512 ptr)