🏡 index : cold-air-networks/mirror-opencl-cts.git

📄 .appveyor.yml
📄 .clang-format
📄 .gitattributes
📁 .github
📁 workflows
📄 presubmit.yml
📄 CMakeLists.txt
📄 CODE_OF_CONDUCT.md
📄 LICENSE.txt
📄 README.md
📄 check-format.sh
📄 presubmit.sh
📄 readme-spir-v-binaries.txt
📁 test_common
📄 CMakeLists.txt
📁 autotest
📄 autotest.hpp
📄 test_suite.hpp
📄 config.hpp
📁 gl
📄 gl_headers.h
📄 helpers.cpp
📄 helpers.h
📄 setup.h
📄 setup_osx.cpp
📄 setup_win32.cpp
📄 setup_x11.cpp
📁 gles
📄 gl_headers.h
📄 helpers.cpp
📄 helpers.h
📄 setup.h
📁 harness
📄 ThreadPool.cpp
📄 ThreadPool.h
📄 alloc.h
📄 clImageHelper.h
📄 cl_offline_compiler-interface.txt
📄 compat.h
📄 conversions.cpp
📄 conversions.h
📄 crc32.cpp
📄 crc32.h
📄 deviceInfo.cpp
📄 deviceInfo.h
📄 errorHelpers.cpp
📄 errorHelpers.h
📄 featureHelpers.cpp
📄 featureHelpers.h
📄 fpcontrol.h
📄 genericThread.cpp
📄 genericThread.h
📄 imageHelpers.cpp
📄 imageHelpers.h
📄 kernelHelpers.cpp
📄 kernelHelpers.h
📄 mingw_compat.c
📄 mingw_compat.h
📄 msvc9.c
📄 mt19937.cpp
📄 mt19937.h
📄 os_helpers.cpp
📄 os_helpers.h
📄 parseParameters.cpp
📄 parseParameters.h
📄 propertyHelpers.cpp
📄 propertyHelpers.h
📄 ref_counting.h
📄 rounding_mode.cpp
📄 rounding_mode.h
📄 testHarness.cpp
📄 testHarness.h
📄 test_mt19937.c
📄 threadTesting.cpp
📄 threadTesting.h
📄 typeWrappers.cpp
📄 typeWrappers.h
📁 miniz
📄 CMakeLists.txt
📄 miniz.c
📄 miniz.h
📁 test_conformance
📄 CMakeCommon.txt
📄 CMakeLists.txt
📁 SVM
📄 CMakeLists.txt
📄 common.h
📄 main.cpp
📄 test_allocate_shared_buffer.cpp
📄 test_byte_granularity.cpp
📄 test_cross_buffer_pointers.cpp
📄 test_enqueue_api.cpp
📄 test_fine_grain_memory_consistency.cpp
📄 test_fine_grain_sync_buffers.cpp
📄 test_migrate.cpp
📄 test_pointer_passing.cpp
📄 test_set_kernel_exec_info_svm_ptrs.cpp
📄 test_shared_address_space_coarse_grain.cpp
📄 test_shared_address_space_fine_grain.cpp
📄 test_shared_address_space_fine_grain_buffers.cpp
📄 test_shared_sub_buffers.cpp
📁 allocations
📄 CMakeLists.txt
📄 allocation_execute.cpp
📄 allocation_execute.h
📄 allocation_fill.cpp
📄 allocation_fill.h
📄 allocation_functions.cpp
📄 allocation_functions.h
📄 allocation_utils.cpp
📄 allocation_utils.h
📄 main.cpp
📄 testBase.h
📁 api
📄 CMakeLists.txt
📄 main.cpp
📄 negative_platform.cpp
📄 procs.h
📄 testBase.h
📄 test_api_consistency.cpp
📄 test_api_min_max.cpp
📄 test_binary.cpp
📄 test_bool.cpp
📄 test_clone_kernel.cpp
📄 test_context_destructor_callback.cpp
📄 test_create_context_from_type.cpp
📄 test_create_kernels.cpp
📄 test_device_min_data_type_align_size_alignment.cpp
📄 test_kernel_arg_changes.cpp
📄 test_kernel_arg_info.cpp
📄 test_kernel_arg_info_compatibility.cpp
📄 test_kernel_arg_multi_setup.cpp
📄 test_kernel_private_memory_size.cpp
📄 test_kernels.cpp
📄 test_mem_object_info.cpp
📄 test_mem_object_properties_queries.cpp
📄 test_mem_objects.cpp
📄 test_min_image_formats.cpp
📄 test_native_kernel.cpp
📄 test_null_buffer_arg.cpp
📄 test_pipe_properties_queries.cpp
📄 test_platform.cpp
📄 test_queries.cpp
📄 test_queue.cpp
📄 test_queue_hint.cpp
📄 test_queue_properties.cpp
📄 test_queue_properties_queries.cpp
📄 test_retain.cpp
📄 test_retain_program.cpp
📄 test_sub_group_dispatch.cpp
📄 test_zero_sized_enqueue.cpp
📁 atomics
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 testBase.h
📄 test_atomics.cpp
📄 test_indexed_cases.cpp
📁 basic
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 run_array
📄 run_array_image_copy
📄 run_image
📄 run_multi_read_image
📄 test_arraycopy.cpp
📄 test_arrayimagecopy.cpp
📄 test_arrayimagecopy3d.cpp
📄 test_arrayreadwrite.cpp
📄 test_astype.cpp
📄 test_async_copy.cpp
📄 test_async_copy2D.cpp
📄 test_async_copy3D.cpp
📄 test_async_copy_fence.cpp
📄 test_async_strided_copy.cpp
📄 test_barrier.cpp
📄 test_basic_parameter_types.cpp
📄 test_bufferreadwriterect.cpp
📄 test_constant.cpp
📄 test_constant_source.cpp
📄 test_createkernelsinprogram.cpp
📄 test_enqueue_map.cpp
📄 test_enqueued_local_size.cpp
📄 test_explicit_s2v.cpp
📄 test_float2int.cpp
📄 test_fpmath_float.cpp
📄 test_fpmath_float2.cpp
📄 test_fpmath_float4.cpp
📄 test_get_linear_ids.cpp
📄 test_global_linear_id.cpp
📄 test_global_work_offsets.cpp
📄 test_hiloeo.cpp
📄 test_hostptr.cpp
📄 test_if.cpp
📄 test_imagecopy.cpp
📄 test_imagecopy3d.cpp
📄 test_imagedim.cpp
📄 test_imagenpot.cpp
📄 test_imagerandomcopy.cpp
📄 test_imagereadwrite.cpp
📄 test_imagereadwrite3d.cpp
📄 test_int2float.cpp
📄 test_intmath.cpp
📄 test_kernel_call_kernel_function.cpp
📄 test_kernel_memory_alignment.cpp
📄 test_local.cpp
📄 test_local_kernel_scope.cpp
📄 test_local_linear_id.cpp
📄 test_loop.cpp
📄 test_multireadimagemultifmt.cpp
📄 test_multireadimageonefmt.cpp
📄 test_numeric_constants.cpp
📄 test_pointercast.cpp
📄 test_preprocessors.cpp
📄 test_progvar.cpp
📄 test_queue_priority.cpp
📄 test_readimage.cpp
📄 test_readimage3d.cpp
📄 test_readimage3d_fp32.cpp
📄 test_readimage3d_int16.cpp
📄 test_readimage_fp32.cpp
📄 test_readimage_int16.cpp
📄 test_rw_image_access_qualifier.cpp
📄 test_simple_image_pitch.cpp
📄 test_sizeof.cpp
📄 test_vec_type_hint.cpp
📄 test_vector_creation.cpp
📄 test_vector_swizzle.cpp
📄 test_vloadstore.cpp
📄 test_wg_barrier.cpp
📄 test_work_item_functions.cpp
📄 test_writeimage.cpp
📄 test_writeimage_fp32.cpp
📄 test_writeimage_int16.cpp
📁 buffers
📄 CMakeLists.txt
📄 array_info.cpp
📄 main.cpp
📄 procs.h
📄 test_buffer_copy.cpp
📄 test_buffer_fill.cpp
📄 test_buffer_map.cpp
📄 test_buffer_mem.cpp
📄 test_buffer_migrate.cpp
📄 test_buffer_read.cpp
📄 test_buffer_write.cpp
📄 test_image_migrate.cpp
📄 test_sub_buffers.cpp
📁 c11_atomics
📄 CMakeLists.txt
📄 common.cpp
📄 common.h
📄 host_atomics.cpp
📄 host_atomics.h
📄 main.cpp
📄 test_atomics.cpp
📁 clcpp
📄 CMakeLists.txt
📁 address_spaces
📄 CMakeLists.txt
📄 common.hpp
📄 main.cpp
📄 test_pointer_types.hpp
📄 test_storage_types.hpp
📁 api
📄 CMakeLists.txt
📄 main.cpp
📄 test_ctors.hpp
📄 test_ctors_dtors.hpp
📄 test_dtors.hpp
📄 test_spec_consts.hpp
📁 atomics
📄 CMakeLists.txt
📄 atomic_fetch.hpp
📄 main.cpp
📁 attributes
📄 CMakeLists.txt
📄 main.cpp
📄 test_ivdep.hpp
📄 test_max_size.hpp
📄 test_required_num_sub_groups.hpp
📄 common.hpp
📁 common_funcs
📄 CMakeLists.txt
📄 common_funcs.hpp
📄 main.cpp
📁 convert
📄 CMakeLists.txt
📄 convert_cast.hpp
📄 main.cpp
📁 device_queue
📄 CMakeLists.txt
📄 main.cpp
📄 test_enqueue.hpp
📄 funcs_test_utils.hpp
📁 geometric_funcs
📄 CMakeLists.txt
📄 fast_geometric_funcs.hpp
📄 geometric_funcs.hpp
📄 main.cpp
📁 images
📄 CMakeLists.txt
📄 common.hpp
📄 main.cpp
📄 test_read.hpp
📄 test_sample.hpp
📄 test_write.hpp
📁 integer_funcs
📄 24bit_funcs.hpp
📄 CMakeLists.txt
📄 bitwise_funcs.hpp
📄 common.hpp
📄 main.cpp
📄 numeric_funcs.hpp
📁 math_funcs
📄 CMakeLists.txt
📄 common.hpp
📄 comparison_funcs.hpp
📄 exponential_funcs.hpp
📄 floating_point_funcs.hpp
📄 half_math_funcs.hpp
📄 logarithmic_funcs.hpp
📄 main.cpp
📄 other_funcs.hpp
📄 power_funcs.hpp
📄 reference.hpp
📄 trigonometric_funcs.hpp
📁 pipes
📄 CMakeLists.txt
📄 main.cpp
📄 test_pipes.hpp
📁 program_scope_ctors_dtors
📄 CMakeLists.txt
📄 common.hpp
📄 main.cpp
📄 test_ctors_dtors.hpp
📁 reinterpret
📄 CMakeLists.txt
📄 as_type.hpp
📄 main.cpp
📁 relational_funcs
📄 CMakeLists.txt
📄 common.hpp
📄 comparison_funcs.hpp
📄 main.cpp
📄 select_funcs.hpp
📄 test_funcs.hpp
📁 spec_constants
📄 CMakeLists.txt
📄 common.hpp
📄 main.cpp
📄 test_spec_consts_attributes.hpp
📄 test_spec_consts_if.hpp
📄 test_spec_consts_init_vars.hpp
📄 spirv10_2016.04.27.7z
📁 subgroups
📄 CMakeLists.txt
📄 common.hpp
📄 main.cpp
📄 test_sg_all.hpp
📄 test_sg_any.hpp
📄 test_sg_broadcast.hpp
📄 test_sg_reduce.hpp
📄 test_sg_scan_exclusive.hpp
📄 test_sg_scan_inclusive.hpp
📁 synchronization
📄 CMakeLists.txt
📄 main.cpp
📁 named_barrier
📄 common.hpp
📄 test_named_barrier.hpp
📄 test_spec_example.hpp
📄 test_sub_group_barrier.hpp
📄 test_work_group_barrier.hpp
📁 utils_common
📄 errors.hpp
📄 is_vector_type.hpp
📄 kernel_helpers.hpp
📄 make_vector_type.hpp
📄 scalar_type.hpp
📄 string.hpp
📄 type_name.hpp
📄 type_supported.hpp
📄 vector_size.hpp
📁 utils_test
📄 binary.hpp
📄 compare.hpp
📁 detail
📄 base_func_type.hpp
📄 vec_helpers.hpp
📄 generate_inputs.hpp
📄 ternary.hpp
📄 unary.hpp
📁 vload_vstore
📄 CMakeLists.txt
📄 common.hpp
📄 half_utils.hpp
📄 main.cpp
📄 vload_funcs.hpp
📄 vstore_funcs.hpp
📁 workgroups
📄 CMakeLists.txt
📄 common.hpp
📄 main.cpp
📄 test_wg_all.hpp
📄 test_wg_any.hpp
📄 test_wg_broadcast.hpp
📄 test_wg_reduce.hpp
📄 test_wg_scan_exclusive.hpp
📄 test_wg_scan_inclusive.hpp
📁 workitems
📄 CMakeLists.txt
📄 main.cpp
📄 test_workitems.hpp
📁 commonfns
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 test_binary_fn.cpp
📄 test_clamp.cpp
📄 test_degrees.cpp
📄 test_fmax.cpp
📄 test_fmaxf.cpp
📄 test_fmin.cpp
📄 test_fminf.cpp
📄 test_max.cpp
📄 test_maxf.cpp
📄 test_min.cpp
📄 test_minf.cpp
📄 test_mix.cpp
📄 test_radians.cpp
📄 test_sign.cpp
📄 test_smoothstep.cpp
📄 test_smoothstepf.cpp
📄 test_step.cpp
📄 test_stepf.cpp
📁 compiler
📄 CMakeLists.txt
📁 includeTestDirectory
📄 testIncludeFile.h
📄 main.cpp
📄 procs.h
📁 secondIncludeTestDirectory
📄 testIncludeFile.h
📄 testBase.h
📄 test_async_build.cpp
📄 test_build_helpers.cpp
📄 test_build_options.cpp
📄 test_compile.cpp
📄 test_compiler_defines_for_extensions.cpp
📄 test_feature_macro.cpp
📄 test_image_macro.cpp
📄 test_opencl_c_versions.cpp
📄 test_pragma_unroll.cpp
📄 test_preprocessor.cpp
📄 test_unload_platform_compiler.cpp
📄 test_unload_platform_compiler_resources.hpp
📄 write_kernel.spvasm32
📄 write_kernel.spvasm64
📁 computeinfo
📄 CMakeLists.txt
📄 conforming_version.cpp
📄 device_uuid.cpp
📄 extended_versioning.cpp
📄 main.cpp
📁 contractions
📄 CMakeLists.txt
📄 contractions.cpp
📁 conversions
📄 CMakeLists.txt
📄 Sleep.cpp
📄 Sleep.h
📄 basic_test_conversions.cpp
📄 basic_test_conversions.h
📄 fplib.cpp
📄 fplib.h
📄 run_batch
📄 test_conversions.cpp
📁 d3d10
📄 CMakeLists.txt
📄 buffer.cpp
📄 harness.cpp
📄 harness.h
📄 main.cpp
📄 misc.cpp
📄 texture2d.cpp
📄 texture3d.cpp
📁 d3d11
📄 CMakeLists.txt
📄 buffer.cpp
📄 harness.cpp
📄 harness.h
📄 main.cpp
📄 misc.cpp
📄 texture2d.cpp
📄 texture3d.cpp
📁 device_execution
📄 CMakeLists.txt
📄 device_info.cpp
📄 device_queue.cpp
📄 enqueue_block.cpp
📄 enqueue_flags.cpp
📄 enqueue_multi_queue.cpp
📄 enqueue_ndrange.cpp
📄 enqueue_profiling.cpp
📄 enqueue_wg_size.cpp
📄 execute_block.cpp
📄 host_multi_queue.cpp
📄 host_queue_order.cpp
📄 main.cpp
📄 nested_blocks.cpp
📄 procs.h
📄 utils.cpp
📄 utils.h
📁 device_partition
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 testBase.h
📄 test_device_partition.cpp
📁 device_timer
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 test_device_timer.cpp
📁 events
📄 CMakeLists.txt
📄 action_classes.cpp
📄 action_classes.h
📄 main.cpp
📄 procs.h
📄 testBase.h
📄 test_callbacks.cpp
📄 test_event_dependencies.cpp
📄 test_events.cpp
📄 test_userevents.cpp
📄 test_userevents_multithreaded.cpp
📄 test_waitlists.cpp
📁 extensions
📄 CMakeLists.txt
📁 cl_ext_cxx_for_opencl
📄 CMakeLists.txt
📄 cxx_for_opencl_ext.cpp
📄 cxx_for_opencl_ver.cpp
📄 main.cpp
📄 procs.h
📁 cl_khr_dx9_media_sharing
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 test_create_context.cpp
📄 test_functions_api.cpp
📄 test_functions_kernel.cpp
📄 test_get_device_ids.cpp
📄 test_interop_sync.cpp
📄 test_memory_access.cpp
📄 test_other_data_types.cpp
📄 utils.cpp
📄 utils.h
📄 wrappers.cpp
📄 wrappers.h
📄 generate_spirv_offline.py
📁 generic_address_space
📄 CMakeLists.txt
📄 advanced_tests.cpp
📄 base.h
📄 basic_tests.cpp
📄 main.cpp
📄 stress_tests.cpp
📁 geometrics
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 testBase.h
📄 test_geometrics.cpp
📄 test_geometrics_double.cpp
📁 gl
📄 CMakeLists.txt
📁 GLEW
📁 GL
📄 eglew.h
📄 glew.h
📄 glxew.h
📄 wglew.h
📄 glew.c
📄 common.h
📄 helpers.cpp
📄 main.cpp
📄 procs.h
📄 testBase.h
📄 test_buffers.cpp
📄 test_fence_sync.cpp
📄 test_image_methods.cpp
📄 test_images_1D.cpp
📄 test_images_1Darray.cpp
📄 test_images_2D.cpp
📄 test_images_2Darray.cpp
📄 test_images_3D.cpp
📄 test_images_depth.cpp
📄 test_images_getinfo_common.cpp
📄 test_images_multisample.cpp
📄 test_images_read_common.cpp
📄 test_images_write_common.cpp
📄 test_renderbuffer.cpp
📄 test_renderbuffer_info.cpp
📁 gles
📄 CMakeLists.txt
📄 helpers.cpp
📄 main.cpp
📄 procs.h
📄 setup_egl.cpp
📄 testBase.h
📄 test_buffers.cpp
📄 test_fence_sync.cpp
📄 test_images_2D.cpp
📄 test_images_2D_info.cpp
📄 test_images_3D.cpp
📄 test_images_3D_info.cpp
📄 test_renderbuffer.cpp
📄 test_renderbuffer_info.cpp
📁 half
📄 CMakeLists.txt
📄 Test_roundTrip.cpp
📄 Test_vLoadHalf.cpp
📄 Test_vStoreHalf.cpp
📄 cl_utils.cpp
📄 cl_utils.h
📄 main.cpp
📄 test_config.h
📄 tests.h
📁 images
📄 CMakeLists.txt
📁 clCopyImage
📄 CMakeLists.txt
📄 main.cpp
📄 test_copy_1D.cpp
📄 test_copy_1D_array.cpp
📄 test_copy_2D.cpp
📄 test_copy_2D_2D_array.cpp
📄 test_copy_2D_3D.cpp
📄 test_copy_2D_array.cpp
📄 test_copy_3D.cpp
📄 test_copy_3D_2D_array.cpp
📄 test_copy_generic.cpp
📄 test_loops.cpp
📁 clFillImage
📄 CMakeLists.txt
📄 main.cpp
📄 test_fill_1D.cpp
📄 test_fill_1D_array.cpp
📄 test_fill_2D.cpp
📄 test_fill_2D_array.cpp
📄 test_fill_3D.cpp
📄 test_fill_generic.cpp
📄 test_loops.cpp
📁 clGetInfo
📄 CMakeLists.txt
📄 main.cpp
📄 test_1D.cpp
📄 test_1D_2D_array.cpp
📄 test_2D.cpp
📄 test_3D.cpp
📄 test_loops.cpp
📁 clReadWriteImage
📄 CMakeLists.txt
📄 main.cpp
📄 test_loops.cpp
📄 test_read_1D.cpp
📄 test_read_1D_array.cpp
📄 test_read_2D.cpp
📄 test_read_2D_array.cpp
📄 test_read_3D.cpp
📄 common.cpp
📄 common.h
📁 kernel_image_methods
📄 CMakeLists.txt
📄 main.cpp
📄 test_1D.cpp
📄 test_1D_array.cpp
📄 test_2D.cpp
📄 test_2D_array.cpp
📄 test_3D.cpp
📄 test_loops.cpp
📁 kernel_read_write
📄 CMakeLists.txt
📄 main.cpp
📄 test_common.cpp
📄 test_common.h
📄 test_iterations.cpp
📄 test_loops.cpp
📄 test_read_1D.cpp
📄 test_read_1D_array.cpp
📄 test_read_2D_array.cpp
📄 test_read_3D.cpp
📄 test_write_1D.cpp
📄 test_write_1D_array.cpp
📄 test_write_2D_array.cpp
📄 test_write_3D.cpp
📄 test_write_image.cpp
📁 samplerlessReads
📄 CMakeLists.txt
📄 main.cpp
📄 test_iterations.cpp
📄 test_loops.cpp
📄 test_read_1D.cpp
📄 test_read_1D_array.cpp
📄 test_read_1D_buffer.cpp
📄 test_read_2D_array.cpp
📄 test_read_3D.cpp
📄 testBase.h
📁 integer_ops
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 testBase.h
📄 test_abs.cpp
📄 test_absdiff.cpp
📄 test_add_sat.cpp
📄 test_int_basic_ops.cpp
📄 test_integers.cpp
📄 test_intmad24.cpp
📄 test_intmul24.cpp
📄 test_popcount.cpp
📄 test_sub_sat.cpp
📄 test_unary_ops.cpp
📄 test_upsample.cpp
📄 verification_and_generation_functions.cpp
📁 math_brute_force
📄 CMakeLists.txt
📄 README.txt
📄 binary_double.cpp
📄 binary_float.cpp
📄 binary_i_double.cpp
📄 binary_i_float.cpp
📄 binary_operator_double.cpp
📄 binary_operator_float.cpp
📄 binary_two_results_i_double.cpp
📄 binary_two_results_i_float.cpp
📄 function_list.cpp
📄 function_list.h
📄 i_unary_double.cpp
📄 i_unary_float.cpp
📄 macro_binary_double.cpp
📄 macro_binary_float.cpp
📄 macro_unary_double.cpp
📄 macro_unary_float.cpp
📄 mad_double.cpp
📄 mad_float.cpp
📄 main.cpp
📄 reference_math.cpp
📄 reference_math.h
📄 run_math_brute_force_in_parallel.py
📄 sleep.cpp
📄 sleep.h
📄 ternary_double.cpp
📄 ternary_float.cpp
📄 test_functions.h
📄 unary_double.cpp
📄 unary_float.cpp
📄 unary_two_results_double.cpp
📄 unary_two_results_float.cpp
📄 unary_two_results_i_double.cpp
📄 unary_two_results_i_float.cpp
📄 unary_u_double.cpp
📄 unary_u_float.cpp
📄 utility.cpp
📄 utility.h
📁 mem_host_flags
📄 CMakeLists.txt
📄 C_host_memory_block.h
📄 checker.h
📄 checker_image_mem_host_no_access.hpp
📄 checker_image_mem_host_read_only.hpp
📄 checker_image_mem_host_write_only.hpp
📄 checker_mem_host_no_access.hpp
📄 checker_mem_host_read_only.hpp
📄 checker_mem_host_write_only.hpp
📄 main.cpp
📄 mem_host_buffer.cpp
📄 mem_host_image.cpp
📄 procs.h
📄 testBase.h
📁 multiple_device_context
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 testBase.h
📄 test_multiple_contexts.cpp
📄 test_multiple_devices.cpp
📁 non_uniform_work_group
📄 CMakeLists.txt
📄 TestNonUniformWorkGroup.cpp
📄 TestNonUniformWorkGroup.h
📄 main.cpp
📄 procs.h
📄 test_advanced_2d.cpp
📄 test_advanced_3d.cpp
📄 test_advanced_other.cpp
📄 test_basic.cpp
📄 tools.cpp
📄 tools.h
📄 opencl_conformance_tests_conversions.csv
📄 opencl_conformance_tests_d3d.csv
📄 opencl_conformance_tests_full.csv
📄 opencl_conformance_tests_full_binary.csv
📄 opencl_conformance_tests_full_no_math_or_conversions.csv
📄 opencl_conformance_tests_full_spirv.csv
📄 opencl_conformance_tests_math.csv
📄 opencl_conformance_tests_quick.csv
📁 pipes
📄 CMakeLists.txt
📄 kernels.h
📄 main.cpp
📄 procs.h
📄 test_pipe_info.cpp
📄 test_pipe_limits.cpp
📄 test_pipe_query_functions.cpp
📄 test_pipe_read_write.cpp
📄 test_pipe_readwrite_errors.cpp
📄 test_pipe_subgroups.cpp
📁 printf
📄 CMakeLists.txt
📄 test_printf.cpp
📄 test_printf.h
📄 util_printf.cpp
📁 profiling
📄 CMakeLists.txt
📄 copy.cpp
📄 execute.cpp
📄 execute_multipass.cpp
📄 main.cpp
📄 procs.h
📄 readArray.cpp
📄 readImage.cpp
📄 writeArray.cpp
📄 writeImage.cpp
📁 relationals
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 testBase.h
📄 test_comparisons_double.cpp
📄 test_comparisons_float.cpp
📄 test_relationals.cpp
📄 test_shuffles.cpp
📄 run_conformance.py
📁 select
📄 CMakeLists.txt
📄 test_select.cpp
📄 test_select.h
📄 util_select.cpp
📁 spir
📄 CMakeLists.txt
📄 api.zip
📄 atomics.zip
📄 basic.zip
📄 binary_type.zip
📄 commonfns.zip
📄 compile_and_link.zip
📄 conversions.zip
📄 datagen.cpp
📄 datagen.h
📄 enum_values.zip
📄 exceptions.h
📄 geometrics.zip
📄 half.zip
📄 images_kernel_read_write.zip
📄 images_samplerlessRead.zip
📄 integer_ops.zip
📄 kernel_attributes.zip
📄 kernel_image_methods.zip
📄 kernelargs.cpp
📄 kernelargs.h
📄 khr.csv
📄 main.cpp
📄 math_brute_force.zip
📄 printf.zip
📄 profiling.zip
📄 relationals.zip
📄 run_build_test.cpp
📄 run_build_test.h
📄 run_services.cpp
📄 run_services.h
📄 sampler_enumeration.zip
📄 select.zip
📄 typeinfo.h
📄 vec_align.zip
📄 vec_step.zip
📁 spirv_new
📄 CMakeLists.txt
📄 README.txt
📄 assemble_spirv.py
📄 main.cpp
📄 procs.h
📁 spirv_asm
📄 atomic_dec_global.spvasm32
📄 atomic_dec_global.spvasm64
📄 atomic_inc_global.spvasm32
📄 atomic_inc_global.spvasm64
📄 branch_conditional.spvasm32
📄 branch_conditional.spvasm64
📄 branch_conditional_weighted.spvasm32
📄 branch_conditional_weighted.spvasm64
📄 branch_simple.spvasm32
📄 branch_simple.spvasm64
📄 composite_construct_int4.spvasm32
📄 composite_construct_int4.spvasm64
📄 composite_construct_struct.spvasm32
📄 composite_construct_struct.spvasm64
📄 constant_char_simple.spvasm32
📄 constant_char_simple.spvasm64
📄 constant_double_simple.spvasm32
📄 constant_double_simple.spvasm64
📄 constant_false_simple.spvasm32
📄 constant_false_simple.spvasm64
📄 constant_float_simple.spvasm32
📄 constant_float_simple.spvasm64
📄 constant_half_simple.spvasm32
📄 constant_half_simple.spvasm64
📄 constant_int3_simple.spvasm32
📄 constant_int3_simple.spvasm64
📄 constant_int4_simple.spvasm32
📄 constant_int4_simple.spvasm64
📄 constant_int_simple.spvasm32
📄 constant_int_simple.spvasm64
📄 constant_long_simple.spvasm32
📄 constant_long_simple.spvasm64
📄 constant_short_simple.spvasm32
📄 constant_short_simple.spvasm64
📄 constant_struct_int_char_simple.spvasm32
📄 constant_struct_int_char_simple.spvasm64
📄 constant_true_simple.spvasm64
📄 constant_uchar_simple.spvasm32
📄 constant_uchar_simple.spvasm64
📄 constant_uint_simple.spvasm32
📄 constant_uint_simple.spvasm64
📄 constant_ulong_simple.spvasm32
📄 constant_ulong_simple.spvasm64
📄 constant_ushort_simple.spvasm32
📄 constant_ushort_simple.spvasm64
📄 copy_char_simple.spvasm32
📄 copy_char_simple.spvasm64
📄 copy_double_simple.spvasm32
📄 copy_double_simple.spvasm64
📄 copy_float_simple.spvasm32
📄 copy_float_simple.spvasm64
📄 copy_half_simple.spvasm32
📄 copy_half_simple.spvasm64
📄 copy_int3_simple.spvasm32
📄 copy_int3_simple.spvasm64
📄 copy_int4_simple.spvasm32
📄 copy_int4_simple.spvasm64
📄 copy_int_simple.spvasm32
📄 copy_int_simple.spvasm64
📄 copy_long_simple.spvasm32
📄 copy_long_simple.spvasm64
📄 copy_short_simple.spvasm32
📄 copy_short_simple.spvasm64
📄 copy_struct_int_char_simple.spvasm32
📄 copy_struct_int_char_simple.spvasm64
📄 copy_struct_int_float_simple.spvasm32
📄 copy_struct_int_float_simple.spvasm64
📄 copy_uint_simple.spvasm64
📄 copy_ulong_simple.spvasm32
📄 copy_ulong_simple.spvasm64
📄 copy_ushort_simple.spvasm32
📄 copy_ushort_simple.spvasm64
📄 decorate_aliased.spvasm32
📄 decorate_aliased.spvasm64
📄 decorate_alignment.spvasm32
📄 decorate_alignment.spvasm64
📄 decorate_constant.spvasm32
📄 decorate_constant.spvasm64
📄 decorate_constant_fail.spvasm32
📄 decorate_constant_fail.spvasm64
📄 decorate_cpacked.spvasm32
📄 decorate_cpacked.spvasm64
📄 decorate_restrict.spvasm32
📄 decorate_restrict.spvasm64
📄 decorate_rounding_rte_double_long.spvasm32
📄 decorate_rounding_rte_double_long.spvasm64
📄 decorate_rounding_rte_float_int.spvasm32
📄 decorate_rounding_rte_float_int.spvasm64
📄 decorate_rounding_rtn_double_long.spvasm32
📄 decorate_rounding_rtn_double_long.spvasm64
📄 decorate_rounding_rtn_float_int.spvasm32
📄 decorate_rounding_rtn_float_int.spvasm64
📄 decorate_rounding_rtp_double_long.spvasm32
📄 decorate_rounding_rtp_double_long.spvasm64
📄 decorate_rounding_rtp_float_int.spvasm32
📄 decorate_rounding_rtp_float_int.spvasm64
📄 decorate_rounding_rtz_double_long.spvasm32
📄 decorate_rounding_rtz_double_long.spvasm64
📄 decorate_saturated_conversion_int.spvasm64
📄 decorate_saturated_conversion_short.spvasm32
📄 decorate_saturated_conversion_short.spvasm64
📄 decorate_saturated_conversion_uchar.spvasm32
📄 decorate_saturated_conversion_uchar.spvasm64
📄 decorate_saturated_conversion_uint.spvasm32
📄 decorate_saturated_conversion_uint.spvasm64
📄 decorate_saturated_conversion_ushort.spvasm32
📄 decorate_saturated_conversion_ushort.spvasm64
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fadd_int.spvasm32
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fadd_int.spvasm64
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fadd_uint.spvasm32
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fadd_uint.spvasm64
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fmul_int.spvasm32
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fmul_int.spvasm64
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fmul_uint.spvasm32
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fmul_uint.spvasm64
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fnegate_int.spvasm32
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fnegate_int.spvasm64
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fshiftleft_int.spvasm32
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fshiftleft_int.spvasm64
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fshiftleft_uint.spvasm32
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fshiftleft_uint.spvasm64
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fsub_int.spvasm32
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fsub_int.spvasm64
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fsub_uint.spvasm32
📄 ext_cl_khr_spirv_no_integer_wrap_decoration_fsub_uint.spvasm64
📄 fadd_double.spvasm32
📄 fadd_double.spvasm64
📄 fadd_double2.spvasm32
📄 fadd_double2.spvasm64
📄 fadd_half.spvasm64
📄 fdiv_double.spvasm32
📄 fdiv_double.spvasm64
📄 fdiv_double2.spvasm32
📄 fdiv_double2.spvasm64
📄 fdiv_float.spvasm32
📄 fdiv_float.spvasm64
📄 fdiv_float4.spvasm32
📄 fdiv_float4.spvasm64
📄 fdiv_half.spvasm32
📄 fdiv_half.spvasm64
📄 fmod_double.spvasm32
📄 fmod_double.spvasm64
📄 fmod_double2.spvasm32
📄 fmod_double2.spvasm64
📄 fmod_float.spvasm32
📄 fmod_float.spvasm64
📄 fmod_float4.spvasm32
📄 fmod_float4.spvasm64
📄 fmod_half.spvasm32
📄 fmod_half.spvasm64
📄 fmul_double.spvasm32
📄 fmul_double.spvasm64
📄 fmul_double2.spvasm32
📄 fmul_double2.spvasm64
📄 fmul_float.spvasm32
📄 frem_double.spvasm32
📄 frem_double.spvasm64
📄 frem_double2.spvasm32
📄 frem_double2.spvasm64
📄 frem_float.spvasm32
📄 frem_float.spvasm64
📄 frem_float4.spvasm32
📄 frem_float4.spvasm64
📄 frem_half.spvasm32
📄 frem_half.spvasm64
📄 fsub_double.spvasm32
📄 fsub_double.spvasm64
📄 fsub_double2.spvasm32
📄 fsub_double2.spvasm64
📄 fsub_float.spvasm32
📄 fsub_float.spvasm64
📄 fsub_float4.spvasm32
📄 fsub_float4.spvasm64
📄 fsub_half.spvasm32
📄 fsub_half.spvasm64
📄 label_simple.spvasm32
📄 label_simple.spvasm64
📄 lifetime_simple.spvasm32
📄 lifetime_simple.spvasm64
📄 linkage_export.spvasm32
📄 linkage_export.spvasm64
📄 linkage_import.spvasm32
📄 linkage_import.spvasm64
📄 loop_merge_branch_conditional_dont_unroll.spvasm32
📄 loop_merge_branch_conditional_dont_unroll.spvasm64
📄 loop_merge_branch_conditional_none.spvasm32
📄 loop_merge_branch_none.spvasm32
📄 loop_merge_branch_none.spvasm64
📄 loop_merge_branch_unroll.spvasm32
📄 loop_merge_branch_unroll.spvasm64
📄 op_function_const.spvasm32
📄 op_function_const.spvasm64
📄 op_function_inline.spvasm32
📄 op_function_inline.spvasm64
📄 op_function_noinline.spvasm32
📄 op_function_noinline.spvasm64
📄 op_function_none.spvasm32
📄 op_function_none.spvasm64
📄 op_function_pure.spvasm32
📄 op_function_pure.spvasm64
📄 op_function_pure_ptr.spvasm32
📄 op_function_pure_ptr.spvasm64
📄 op_neg_double.spvasm32
📄 op_neg_double.spvasm64
📄 op_neg_float.spvasm32
📄 op_neg_float.spvasm64
📄 op_neg_float4.spvasm32
📄 op_neg_float4.spvasm64
📄 op_neg_int.spvasm32
📄 op_neg_int.spvasm64
📄 op_neg_int4.spvasm32
📄 op_neg_int4.spvasm64
📄 op_neg_long.spvasm32
📄 op_neg_long.spvasm64
📄 op_neg_short.spvasm32
📄 op_neg_short.spvasm64
📄 op_not_int.spvasm32
📄 op_not_short.spvasm32
📄 op_not_short.spvasm64
📄 op_spec_constant_double_simple.spvasm32
📄 op_spec_constant_double_simple.spvasm64
📄 op_spec_constant_false_simple.spvasm32
📄 op_spec_constant_false_simple.spvasm64
📄 op_spec_constant_float_simple.spvasm32
📄 op_spec_constant_float_simple.spvasm64
📄 op_spec_constant_half_simple.spvasm32
📄 op_spec_constant_half_simple.spvasm64
📄 op_spec_constant_true_simple.spvasm32
📄 op_spec_constant_true_simple.spvasm64
📄 op_spec_constant_uchar_simple.spvasm32
📄 op_spec_constant_uchar_simple.spvasm64
📄 op_spec_constant_uint_simple.spvasm32
📄 op_spec_constant_uint_simple.spvasm64
📄 op_spec_constant_ulong_simple.spvasm32
📄 op_spec_constant_ulong_simple.spvasm64
📄 op_spec_constant_ushort_simple.spvasm32
📄 op_spec_constant_ushort_simple.spvasm64
📄 opaque.spvasm32
📄 opaque.spvasm64
📄 phi_2.spvasm32
📄 phi_2.spvasm64
📄 phi_3.spvasm32
📄 phi_3.spvasm64
📄 phi_4.spvasm32
📄 phi_4.spvasm64
📄 select_if_dont_flatten.spvasm32
📄 select_if_dont_flatten.spvasm64
📄 select_if_flatten.spvasm32
📄 select_switch_flatten.spvasm32
📄 select_switch_flatten.spvasm64
📄 select_switch_none.spvasm32
📄 select_switch_none.spvasm64
📄 undef_char_simple.spvasm32
📄 undef_char_simple.spvasm64
📄 undef_double_simple.spvasm32
📄 undef_double_simple.spvasm64
📄 undef_false_simple.spvasm32
📄 undef_false_simple.spvasm64
📄 undef_float_simple.spvasm32
📄 undef_float_simple.spvasm64
📄 undef_half_simple.spvasm32
📄 undef_half_simple.spvasm64
📄 undef_int3_simple.spvasm32
📄 undef_int3_simple.spvasm64
📄 undef_int4_simple.spvasm32
📄 undef_int4_simple.spvasm64
📄 undef_int_simple.spvasm32
📄 undef_int_simple.spvasm64
📄 undef_long_simple.spvasm32
📄 undef_long_simple.spvasm64
📄 undef_short_simple.spvasm32
📄 undef_short_simple.spvasm64
📄 undef_struct_int_char_simple.spvasm32
📄 undef_struct_int_char_simple.spvasm64
📄 undef_struct_int_float_simple.spvasm32
📄 undef_struct_int_float_simple.spvasm64
📄 undef_struct_struct_simple.spvasm32
📄 undef_struct_struct_simple.spvasm64
📄 undef_true_simple.spvasm32
📄 undef_ulong_simple.spvasm32
📄 undef_ulong_simple.spvasm64
📄 undef_ushort_simple.spvasm32
📄 undef_ushort_simple.spvasm64
📄 unreachable_simple.spvasm32
📄 unreachable_simple.spvasm64
📄 vector_char16_extract.spvasm32
📄 vector_char16_extract.spvasm64
📄 vector_char16_insert.spvasm32
📄 vector_char16_insert.spvasm64
📄 vector_double2_extract.spvasm32
📄 vector_double2_extract.spvasm64
📄 vector_double2_insert.spvasm32
📄 vector_double2_insert.spvasm64
📄 vector_float4_extract.spvasm32
📄 vector_float4_extract.spvasm64
📄 vector_float4_insert.spvasm32
📄 vector_float4_insert.spvasm64
📄 vector_int4_extract.spvasm32
📄 vector_int4_extract.spvasm64
📄 vector_int4_insert.spvasm32
📄 vector_int4_insert.spvasm64
📄 vector_long2_extract.spvasm32
📄 vector_long2_extract.spvasm64
📄 vector_long2_insert.spvasm32
📄 vector_long2_insert.spvasm64
📄 vector_times_scalar_double.spvasm32
📄 vector_times_scalar_double.spvasm64
📄 vector_times_scalar_float.spvasm32
📄 vector_times_scalar_float.spvasm64
📄 testBase.h
📄 test_cl_khr_spirv_no_integer_wrap_decoration.cpp
📄 test_decorate.cpp
📄 test_get_program_il.cpp
📄 test_linkage.cpp
📄 test_op_atomic.cpp
📄 test_op_branch.cpp
📄 test_op_branch_conditional.cpp
📄 test_op_composite_construct.cpp
📄 test_op_constant.cpp
📄 test_op_copy_object.cpp
📄 test_op_fmath.cpp
📄 test_op_function.cpp
📄 test_op_lifetime.cpp
📄 test_op_loop_merge.cpp
📄 test_op_negate.cpp
📄 test_op_opaque.cpp
📄 test_op_phi.cpp
📄 test_op_selection_merge.cpp
📄 test_op_spec_constant.cpp
📄 test_op_undef.cpp
📄 test_op_vector_extract.cpp
📄 test_op_vector_insert.cpp
📄 test_op_vector_times_scalar.cpp
📄 types.hpp
📁 subgroups
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 subgroup_common_kernels.cpp
📄 subgroup_common_kernels.h
📄 subgroup_common_templates.h
📄 subhelpers.h
📄 test_barrier.cpp
📄 test_ifp.cpp
📄 test_queries.cpp
📄 test_subgroup.cpp
📄 test_subgroup_ballot.cpp
📄 test_subgroup_clustered_reduce.cpp
📄 test_subgroup_extended_types.cpp
📄 test_subgroup_non_uniform_arithmetic.cpp
📄 test_subgroup_non_uniform_vote.cpp
📄 test_subgroup_shuffle.cpp
📄 test_subgroup_shuffle_relative.cpp
📄 test_workitem.cpp
📄 submission_details_template.txt
📁 thread_dimensions
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 test_thread_dimensions.cpp
📁 vectors
📄 CMakeLists.txt
📄 defines.h
📄 globals.cpp
📄 main.cpp
📄 procs.h
📄 structs.cpp
📄 structs.h
📄 testBase.h
📄 test_step.cpp
📄 test_vec_align.cpp
📄 type_replacer.cpp
📄 type_replacer.h
📁 workgroups
📄 CMakeLists.txt
📄 main.cpp
📄 procs.h
📄 testBase.h
📄 test_wg_all.cpp
📄 test_wg_any.cpp
📄 test_wg_broadcast.cpp
📄 test_wg_reduce.cpp
📄 test_wg_reduce_max.cpp
📄 test_wg_reduce_min.cpp
📄 test_wg_scan_exclusive_add.cpp
📄 test_wg_scan_exclusive_max.cpp
📄 test_wg_scan_exclusive_min.cpp
📄 test_wg_scan_inclusive_add.cpp
📄 test_wg_scan_inclusive_max.cpp
📄 test_wg_scan_inclusive_min.cpp 
//
// Copyright (c) 2017 The Khronos Group Inc.
// 
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "harness/compat.h"

#include "basic_test_conversions.h"
#include <limits.h>
#include <string.h>

#include "harness/mt19937.h"

#if (defined(__arm__) || defined(__aarch64__)) && defined(__GNUC__)
#include "fplib.h"
#endif

#if (defined(__arm__) || defined(__aarch64__)) && defined(__GNUC__)
/* Rounding modes and saturation for use with qcom 64 bit to float conversion library */
    bool            qcom_sat;
    roundingMode    qcom_rm;
#endif

static inline cl_ulong random64( MTdata d );

#if defined (_WIN32)
    #include <mmintrin.h>
    #include <emmintrin.h>
#else // !_WIN32
#if defined (__SSE__ )
    #include <xmmintrin.h>
#endif
#if defined (__SSE2__ )
    #include <emmintrin.h>
#endif
#endif // _WIN32

const char *gTypeNames[ kTypeCount ] = {
                                            "uchar", "char",
                                            "ushort", "short",
                                            "uint",   "int",
                                            "float", "double",
                                            "ulong", "long"
                                        };

const char *gRoundingModeNames[ kRoundingModeCount ] = {
                                                            "",
                                                            "_rte",
                                                            "_rtp",
                                                            "_rtn",
                                                            "_rtz"
                                                        };

const char *gSaturationNames[ 2 ] = { "", "_sat" };

size_t gTypeSizes[ kTypeCount ] = {
                                    sizeof( cl_uchar ), sizeof( cl_char ),
                                    sizeof( cl_ushort ), sizeof( cl_short ),
                                    sizeof( cl_uint ), sizeof( cl_int ),
                                    sizeof( cl_float ), sizeof( cl_double ),
                                    sizeof( cl_ulong ), sizeof( cl_long ),
                                };

long lrintf_clamped( float f );
long lrintf_clamped( float f )
{
    static const float magic[2] = { MAKE_HEX_FLOAT( 0x1.0p23f, 0x1, 23), - MAKE_HEX_FLOAT( 0x1.0p23f, 0x1, 23) };

    if( f >= -(float) LONG_MIN )
        return LONG_MAX;

    if( f <= (float) LONG_MIN )
        return LONG_MIN;

    // Round fractional values to integer in round towards nearest mode
    if( fabsf(f) < MAKE_HEX_FLOAT( 0x1.0p23f, 0x1, 23 ) )
    {
        volatile float x = f;
        float magicVal = magic[ f < 0 ];

#if defined( __SSE__ ) || defined (_WIN32)
        // Defeat x87 based arithmetic, which cant do FTZ, and will round this incorrectly
        __m128 v = _mm_set_ss( x );
        __m128 m = _mm_set_ss( magicVal );
        v = _mm_add_ss( v, m );
        v = _mm_sub_ss( v, m );
        _mm_store_ss( (float*) &x, v );
#else
        x += magicVal;
        x -= magicVal;
#endif
        f = x;
    }

    return (long) f;
}

long long llrintf_clamped( float f );
long long llrintf_clamped( float f )
{
    static const float magic[2] = { MAKE_HEX_FLOAT( 0x1.0p23f, 0x1, 23), - MAKE_HEX_FLOAT( 0x1.0p23f, 0x1, 23) };

    if( f >= -(float) LLONG_MIN )
        return LLONG_MAX;

    if( f <= (float) LLONG_MIN )
        return LLONG_MIN;

    // Round fractional values to integer in round towards nearest mode
    if( fabsf(f) < MAKE_HEX_FLOAT(0x1.0p23f, 0x1L, 23) )
    {
        volatile float x = f;
        float magicVal = magic[ f < 0 ];
#if defined( __SSE__ ) || defined (_WIN32)
        // Defeat x87 based arithmetic, which cant do FTZ, and will round this incorrectly
        __m128 v = _mm_set_ss( x );
        __m128 m = _mm_set_ss( magicVal );
        v = _mm_add_ss( v, m );
        v = _mm_sub_ss( v, m );
        _mm_store_ss( (float*) &x, v );
#else
        x += magicVal;
        x -= magicVal;
#endif
        f = x;
    }

    return (long long) f;
}

long lrint_clamped( double f );
long lrint_clamped( double f )
{
    static const double magic[2] = { MAKE_HEX_DOUBLE(0x1.0p52, 0x1LL, 52), MAKE_HEX_DOUBLE(-0x1.0p52, -0x1LL, 52) };

    if( sizeof( long ) > 4 )
    {
        if( f >= -(double) LONG_MIN )
            return LONG_MAX;
    }
    else
    {
        if( f >= LONG_MAX )
            return LONG_MAX;
    }

    if( f <= (double) LONG_MIN )
        return LONG_MIN;

    // Round fractional values to integer in round towards nearest mode
    if( fabs(f) < MAKE_HEX_DOUBLE(0x1.0p52, 0x1LL, 52) )
    {
        volatile double x = f;
        double magicVal = magic[ f < 0 ];
#if defined( __SSE2__ ) || defined (_MSC_VER)
        // Defeat x87 based arithmetic, which cant do FTZ, and will round this incorrectly
        __m128d v = _mm_set_sd( x );
        __m128d m = _mm_set_sd( magicVal );
        v = _mm_add_sd( v, m );
        v = _mm_sub_sd( v, m );
        _mm_store_sd( (double*) &x, v );
#else
        x += magicVal;
        x -= magicVal;
#endif
        f = x;
    }

    return (long) f;
}

long long llrint_clamped( double f );
long long llrint_clamped( double f )
{
    static const double magic[2] = { MAKE_HEX_DOUBLE(0x1.0p52, 0x1LL, 52), MAKE_HEX_DOUBLE(-0x1.0p52, -0x1LL, 52) };

    if( f >= -(double) LLONG_MIN )
        return LLONG_MAX;

    if( f <= (double) LLONG_MIN )
        return LLONG_MIN;

    // Round fractional values to integer in round towards nearest mode
    if( fabs(f) < MAKE_HEX_DOUBLE(0x1.0p52, 0x1LL, 52) )
    {
        volatile double x = f;
        double magicVal = magic[ f < 0 ];
#if defined( __SSE2__ ) || defined (_MSC_VER)
        // Defeat x87 based arithmetic, which cant do FTZ, and will round this incorrectly
        __m128d v = _mm_set_sd( x );
        __m128d m = _mm_set_sd( magicVal );
        v = _mm_add_sd( v, m );
        v = _mm_sub_sd( v, m );
        _mm_store_sd( (double*) &x, v );
#else
        x += magicVal;
        x -= magicVal;
#endif
        f = x;
    }

    return (long long) f;
}


/*
    Names created as:

    #include <stdio.h>

    const char *names[] = { "uchar", "char", "ushort", "short", "uint", "int", "float", "double", "ulong", "long" };

    int main( void )
    {

        int i,j;

        for( i = 0; i < sizeof( names ) / sizeof( names[0] ); i++ )
            for( j = 0; j < sizeof( names ) / sizeof( names[0] ); j++ )
            {
                if( j == i )
                    continue;

                vlog( "void %s2%s( void *, void *);\n", names[i], names[j] );
            }


        return 0;
    }
*/

static float my_fabsf( float x );
static double my_fabs( double x );



static void uchar2char( void *, void *);
static void uchar2ushort( void *, void *);
static void uchar2short( void *, void *);
static void uchar2uint( void *, void *);
static void uchar2int( void *, void *);
static void uchar2float( void *, void *);
static void uchar2double( void *, void *);
static void uchar2ulong( void *, void *);
static void uchar2long( void *, void *);
static void char2uchar( void *, void *);
static void char2ushort( void *, void *);
static void char2short( void *, void *);
static void char2uint( void *, void *);
static void char2int( void *, void *);
static void char2float( void *, void *);
static void char2double( void *, void *);
static void char2ulong( void *, void *);
static void char2long( void *, void *);
static void ushort2uchar( void *, void *);
static void ushort2char( void *, void *);
static void ushort2short( void *, void *);
static void ushort2uint( void *, void *);
static void ushort2int( void *, void *);
static void ushort2float( void *, void *);
static void ushort2double( void *, void *);
static void ushort2ulong( void *, void *);
static void ushort2long( void *, void *);
static void short2uchar( void *, void *);
static void short2char( void *, void *);
static void short2ushort( void *, void *);
static void short2uint( void *, void *);
static void short2int( void *, void *);
static void short2float( void *, void *);
static void short2double( void *, void *);
static void short2ulong( void *, void *);
static void short2long( void *, void *);
static void uint2uchar( void *, void *);
static void uint2char( void *, void *);
static void uint2ushort( void *, void *);
static void uint2short( void *, void *);
static void uint2int( void *, void *);
static void uint2float( void *, void *);
static void uint2double( void *, void *);
static void uint2ulong( void *, void *);
static void uint2long( void *, void *);
static void int2uchar( void *, void *);
static void int2char( void *, void *);
static void int2ushort( void *, void *);
static void int2short( void *, void *);
static void int2uint( void *, void *);
static void int2float( void *, void *);
static void int2double( void *, void *);
static void int2ulong( void *, void *);
static void int2long( void *, void *);
static void float2uchar( void *, void *);
static void float2char( void *, void *);
static void float2ushort( void *, void *);
static void float2short( void *, void *);
static void float2uint( void *, void *);
static void float2int( void *, void *);
static void float2double( void *, void *);
static void float2ulong( void *, void *);
static void float2long( void *, void *);
static void double2uchar( void *, void *);
static void double2char( void *, void *);
static void double2ushort( void *, void *);
static void double2short( void *, void *);
static void double2uint( void *, void *);
static void double2int( void *, void *);
static void double2float( void *, void *);
static void double2ulong( void *, void *);
static void double2long( void *, void *);
static void ulong2uchar( void *, void *);
static void ulong2char( void *, void *);
static void ulong2ushort( void *, void *);
static void ulong2short( void *, void *);
static void ulong2uint( void *, void *);
static void ulong2int( void *, void *);
static void ulong2float( void *, void *);
static void ulong2double( void *, void *);
static void ulong2long( void *, void *);
static void long2uchar( void *, void *);
static void long2char( void *, void *);
static void long2ushort( void *, void *);
static void long2short( void *, void *);
static void long2uint( void *, void *);
static void long2int( void *, void *);
static void long2float( void *, void *);
static void long2double( void *, void *);
static void long2ulong( void *, void *);

/*
    Conversion list created as

    #include <stdio.h>

    const char *names[] = { "uchar", "char", "ushort", "short", "uint", "int", "float", "double", "ulong", "long" };

    int main( void )
    {

        int i,j;

        for( i = 0; i < sizeof( names ) / sizeof( names[0] ); i++ )
        {
            vlog( "{ " );
            for( j = 0; j < sizeof( names ) / sizeof( names[0] ); j++ )
            {
                if( j == i )
                    vlog( "          NULL, " );
                else
                {
                    char s[64];
                    sprintf( s, "%s2%s,", names[j], names[i] );
                    vlog( "%15s ", s );
                }
            }
            vlog( "},\n" );
        }

        return 0;
    }

 */
/*
Convert gConversions[kTypeCount][kTypeCount] = {
{           NULL,     char2uchar,   ushort2uchar,    short2uchar,     uint2uchar,      int2uchar,    float2uchar,   double2uchar,    ulong2uchar,     long2uchar, },
{     uchar2char,           NULL,    ushort2char,     short2char,      uint2char,       int2char,     float2char,    double2char,     ulong2char,      long2char, },
{   uchar2ushort,    char2ushort,           NULL,   short2ushort,    uint2ushort,     int2ushort,   float2ushort,  double2ushort,   ulong2ushort,    long2ushort, },
{    uchar2short,     char2short,   ushort2short,           NULL,     uint2short,      int2short,    float2short,   double2short,    ulong2short,     long2short, },
{     uchar2uint,      char2uint,    ushort2uint,     short2uint,           NULL,       int2uint,     float2uint,    double2uint,     ulong2uint,      long2uint, },
{      uchar2int,       char2int,     ushort2int,      short2int,       uint2int,           NULL,      float2int,     double2int,      ulong2int,       long2int, },
{    uchar2float,     char2float,   ushort2float,    short2float,     uint2float,      int2float,           NULL,   double2float,    ulong2float,     long2float, },
{   uchar2double,    char2double,  ushort2double,   short2double,    uint2double,     int2double,   float2double,           NULL,   ulong2double,    long2double, },
{    uchar2ulong,     char2ulong,   ushort2ulong,    short2ulong,     uint2ulong,      int2ulong,    float2ulong,   double2ulong,           NULL,     long2ulong, },
{     uchar2long,      char2long,    ushort2long,     short2long,      uint2long,       int2long,     float2long,    double2long,     ulong2long,           NULL, } };
*/

static void uchar2char_sat( void *, void *);
static void uchar2ushort_sat( void *, void *);
static void uchar2short_sat( void *, void *);
static void uchar2uint_sat( void *, void *);
static void uchar2int_sat( void *, void *);
static void uchar2float_sat( void *, void *);
static void uchar2double_sat( void *, void *);
static void uchar2ulong_sat( void *, void *);
static void uchar2long_sat( void *, void *);
static void char2uchar_sat( void *, void *);
static void char2ushort_sat( void *, void *);
static void char2short_sat( void *, void *);
static void char2uint_sat( void *, void *);
static void char2int_sat( void *, void *);
static void char2float_sat( void *, void *);
static void char2double_sat( void *, void *);
static void char2ulong_sat( void *, void *);
static void char2long_sat( void *, void *);
static void ushort2uchar_sat( void *, void *);
static void ushort2char_sat( void *, void *);
static void ushort2short_sat( void *, void *);
static void ushort2uint_sat( void *, void *);
static void ushort2int_sat( void *, void *);
static void ushort2float_sat( void *, void *);
static void ushort2double_sat( void *, void *);
static void ushort2ulong_sat( void *, void *);
static void ushort2long_sat( void *, void *);
static void short2uchar_sat( void *, void *);
static void short2char_sat( void *, void *);
static void short2ushort_sat( void *, void *);
static void short2uint_sat( void *, void *);
static void short2int_sat( void *, void *);
static void short2float_sat( void *, void *);
static void short2double_sat( void *, void *);
static void short2ulong_sat( void *, void *);
static void short2long_sat( void *, void *);
static void uint2uchar_sat( void *, void *);
static void uint2char_sat( void *, void *);
static void uint2ushort_sat( void *, void *);
static void uint2short_sat( void *, void *);
static void uint2int_sat( void *, void *);
static void uint2float_sat( void *, void *);
static void uint2double_sat( void *, void *);
static void uint2ulong_sat( void *, void *);
static void uint2long_sat( void *, void *);
static void int2uchar_sat( void *, void *);
static void int2char_sat( void *, void *);
static void int2ushort_sat( void *, void *);
static void int2short_sat( void *, void *);
static void int2uint_sat( void *, void *);
static void int2float_sat( void *, void *);
static void int2double_sat( void *, void *);
static void int2ulong_sat( void *, void *);
static void int2long_sat( void *, void *);
static void float2uchar_sat( void *, void *);
static void float2char_sat( void *, void *);
static void float2ushort_sat( void *, void *);
static void float2short_sat( void *, void *);
static void float2uint_sat( void *, void *);
static void float2int_sat( void *, void *);
static void float2double_sat( void *, void *);
static void float2ulong_sat( void *, void *);
static void float2long_sat( void *, void *);
static void double2uchar_sat( void *, void *);
static void double2char_sat( void *, void *);
static void double2ushort_sat( void *, void *);
static void double2short_sat( void *, void *);
static void double2uint_sat( void *, void *);
static void double2int_sat( void *, void *);
static void double2float_sat( void *, void *);
static void double2ulong_sat( void *, void *);
static void double2long_sat( void *, void *);
static void ulong2uchar_sat( void *, void *);
static void ulong2char_sat( void *, void *);
static void ulong2ushort_sat( void *, void *);
static void ulong2short_sat( void *, void *);
static void ulong2uint_sat( void *, void *);
static void ulong2int_sat( void *, void *);
static void ulong2float_sat( void *, void *);
static void ulong2double_sat( void *, void *);
static void ulong2long_sat( void *, void *);
static void long2uchar_sat( void *, void *);
static void long2char_sat( void *, void *);
static void long2ushort_sat( void *, void *);
static void long2short_sat( void *, void *);
static void long2uint_sat( void *, void *);
static void long2int_sat( void *, void *);
static void long2float_sat( void *, void *);
static void long2double_sat( void *, void *);
static void long2ulong_sat( void *, void *);
/*
    #include <stdio.h>

    const char *names[] = { "uchar", "char", "ushort", "short", "uint", "int", "float", "double", "ulong", "long" };

    int main( void )
    {

        int i,j;

        for( i = 0; i < sizeof( names ) / sizeof( names[0] ); i++ )
        {
            vlog( "{ " );
            for( j = 0; j < sizeof( names ) / sizeof( names[0] ); j++ )
            {
                if( j == i )
                    vlog( "             NULL, " );
                else
                {
                    char s[64];
                    sprintf( s, "%s2%s_sat,", names[j], names[i] );
                    vlog( "%18s ", s );
                }
            }
            vlog( "},\n" );
        }

        return 0;
    }

Convert gSaturatedConversions[kTypeCount][kTypeCount] = {
{              NULL,    char2uchar_sat,  ushort2uchar_sat,   short2uchar_sat,    uint2uchar_sat,     int2uchar_sat,   float2uchar_sat,  double2uchar_sat,   ulong2uchar_sat,    long2uchar_sat, },
{    uchar2char_sat,              NULL,   ushort2char_sat,    short2char_sat,     uint2char_sat,      int2char_sat,    float2char_sat,   double2char_sat,    ulong2char_sat,     long2char_sat, },
{  uchar2ushort_sat,   char2ushort_sat,              NULL,  short2ushort_sat,   uint2ushort_sat,    int2ushort_sat,  float2ushort_sat, double2ushort_sat,  ulong2ushort_sat,   long2ushort_sat, },
{   uchar2short_sat,    char2short_sat,  ushort2short_sat,              NULL,    uint2short_sat,     int2short_sat,   float2short_sat,  double2short_sat,   ulong2short_sat,    long2short_sat, },
{    uchar2uint_sat,     char2uint_sat,   ushort2uint_sat,    short2uint_sat,              NULL,      int2uint_sat,    float2uint_sat,   double2uint_sat,    ulong2uint_sat,     long2uint_sat, },
{     uchar2int_sat,      char2int_sat,    ushort2int_sat,     short2int_sat,      uint2int_sat,              NULL,     float2int_sat,    double2int_sat,     ulong2int_sat,      long2int_sat, },
{   uchar2float_sat,    char2float_sat,  ushort2float_sat,   short2float_sat,    uint2float_sat,     int2float_sat,              NULL,  double2float_sat,   ulong2float_sat,    long2float_sat, },
{  uchar2double_sat,   char2double_sat, ushort2double_sat,  short2double_sat,   uint2double_sat,    int2double_sat,  float2double_sat,              NULL,  ulong2double_sat,   long2double_sat, },
{   uchar2ulong_sat,    char2ulong_sat,  ushort2ulong_sat,   short2ulong_sat,    uint2ulong_sat,     int2ulong_sat,   float2ulong_sat,  double2ulong_sat,              NULL,    long2ulong_sat, },
{    uchar2long_sat,     char2long_sat,   ushort2long_sat,    short2long_sat,     uint2long_sat,      int2long_sat,    float2long_sat,   double2long_sat,    ulong2long_sat,              NULL, }
};
*/

/*
    #include <stdio.h>

    const char *names[] = { "uchar", "char", "ushort", "short", "uint", "int", "float", "double", "ulong", "long" };
    const char *types[] = { "uchar", "char", "ushort", "short", "uint", "int", "float", "double", "ulong", "llong" };

    int main( void )
    {

        int i,j;

        for( i = 0; i < sizeof( names ) / sizeof( names[0] ); i++ )
            for( j = 0; j < sizeof( names ) / sizeof( names[0] ); j++ )
            {
                if( j == i )
                    continue;

                switch( i )
                {
                    case 6: //float
                        if( j == 7 )
                            vlog( "void %s2%s( void *out, void *in){ ((%s*) out)[0] = (%s) ((%s*) in)[0]; }\n", names[i], names[i], names[j], types[j], types[i] );
                        else
                            vlog( "void %s2%s( void *out, void *in){ ((%s*) out)[0] = (%s) my_rintf(((%s*) in)[0]); }\n", names[i], names[i], names[j], types[j], types[i] );
                        break;
                    case 7: //double
                        if( j == 6 )
                            vlog( "void %s2%s( void *out, void *in){ ((%s*) out)[0] = (%s) ((%s*) in)[0]; }\n", names[i], names[i], names[j], types[j], types[i] );
                        else
                            vlog( "void %s2%s( void *out, void *in){ ((%s*) out)[0] = (%s) rint(((%s*) in)[0]); }\n", names[i], names[i], names[j], types[j], types[i] );
                        break;
                    default:
                        vlog( "void %s2%s( void *out, void *in){ ((%s*) out)[0] = (%s)
                        ((%s*) in)[0]; }\n", names[i], names[i], names[j], types[j], types[i] );
                        break;
                }
            }


        return 0;
    }
*/

float my_fabsf( float x )
{
    union{ cl_uint u; float f; }u;
    u.f = x;
    u.u &= 0x7fffffff;
    return u.f;
}

double my_fabs( double x )
{
    union{ cl_ulong u; double f; }u;
    u.f = x;
    u.u &= 0x7fffffffffffffffULL;
    return u.f;
}

static float my_rintf( float f );
static float my_rintf( float f )
{
    static const float magic[2] = { MAKE_HEX_FLOAT( 0x1.0p23f, 0x1, 23), - MAKE_HEX_FLOAT( 0x1.0p23f, 0x1, 23) };

    // Round fractional values to integer in round towards nearest mode
    if( fabsf(f) < MAKE_HEX_FLOAT( 0x1.0p23f, 0x1, 23 ) )
    {
        volatile float x = f;
        float magicVal = magic[ f < 0 ];

#if defined( __SSE__ )
        // Defeat x87 based arithmetic, which cant do FTZ, and will round this incorrectly
        __m128 v = _mm_set_ss( x );
        __m128 m = _mm_set_ss( magicVal );
        v = _mm_add_ss( v, m );
        v = _mm_sub_ss( v, m );
        _mm_store_ss( (float*) &x, v );
#else
        x += magicVal;
        x -= magicVal;
#endif
        f = x;
    }

    return f;
}

static void uchar2char( void *out, void *in){ ((char*) out)[0] = ((cl_uchar*) in)[0]; }
static void uchar2ushort( void *out, void *in){ ((cl_ushort*) out)[0] = ((cl_uchar*) in)[0]; }
static void uchar2short( void *out, void *in){ ((short*) out)[0] = ((cl_uchar*) in)[0]; }
static void uchar2uint( void *out, void *in){ ((cl_uint*) out)[0] = ((cl_uchar*) in)[0]; }
static void uchar2int( void *out, void *in){ ((int*) out)[0] = ((cl_uchar*) in)[0]; }
static void uchar2float( void *out, void *in)
{
    cl_uchar l = ((cl_uchar*) in)[0];
    ((float*) out)[0] = (l == 0 ? 0.0f : (float) l);        // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
}
static void uchar2double( void *out, void *in)
{
    cl_uchar l = ((cl_uchar*) in)[0];
    ((double*) out)[0] = (l == 0 ? 0.0 : (double) l);      // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
}
static void uchar2ulong( void *out, void *in){ ((cl_ulong*) out)[0] = ((cl_uchar*) in)[0]; }
static void uchar2long( void *out, void *in){ ((cl_long*) out)[0] = ((cl_uchar*) in)[0]; }
static void char2uchar( void *out, void *in){ ((cl_uchar*) out)[0] = ((cl_char*) in)[0]; }
static void char2ushort( void *out, void *in){ ((cl_ushort*) out)[0] = ((cl_char*) in)[0]; }
static void char2short( void *out, void *in){ ((short*) out)[0] = ((cl_char*) in)[0]; }
static void char2uint( void *out, void *in){ ((cl_uint*) out)[0] = ((cl_char*) in)[0]; }
static void char2int( void *out, void *in){ ((int*) out)[0] = ((cl_char*) in)[0]; }
static void char2float( void *out, void *in)
{
    cl_char l = ((cl_char*) in)[0];
    ((float*) out)[0] = (l == 0 ? 0.0f : (float) l);        // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
}
static void char2double( void *out, void *in)
{
    cl_char l = ((cl_char*) in)[0];
    ((double*) out)[0] = (l == 0 ? 0.0 : (double) l);      // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
}
static void char2ulong( void *out, void *in){ ((cl_ulong*) out)[0] = ((cl_char*) in)[0]; }
static void char2long( void *out, void *in){ ((cl_long*) out)[0] = ((cl_char*) in)[0]; }
static void ushort2uchar( void *out, void *in){ ((cl_uchar*) out)[0] = ((cl_ushort*) in)[0]; }
static void ushort2char( void *out, void *in){ ((char*) out)[0] = ((cl_ushort*) in)[0]; }
static void ushort2short( void *out, void *in){ ((short*) out)[0] = ((cl_ushort*) in)[0]; }
static void ushort2uint( void *out, void *in){ ((cl_uint*) out)[0] = ((cl_ushort*) in)[0]; }
static void ushort2int( void *out, void *in){ ((int*) out)[0] = ((cl_ushort*) in)[0]; }
static void ushort2float( void *out, void *in)
{
    cl_ushort l = ((cl_ushort*) in)[0];
    ((float*) out)[0] = (l == 0 ? 0.0f : (float) l);        // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
}
static void ushort2double( void *out, void *in)
{
    cl_ushort l = ((cl_ushort*) in)[0];
    ((double*) out)[0] = (l == 0 ? 0.0 : (double) l);      // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
}
static void ushort2ulong( void *out, void *in){ ((cl_ulong*) out)[0] = ((cl_ushort*) in)[0]; }
static void ushort2long( void *out, void *in){ ((cl_long*) out)[0] = ((cl_ushort*) in)[0]; }
static void short2uchar( void *out, void *in){ ((cl_uchar*) out)[0] = ((cl_short*) in)[0]; }
static void short2char( void *out, void *in){ ((cl_char*) out)[0] = ((cl_short*) in)[0]; }
static void short2ushort( void *out, void *in){ ((cl_ushort*) out)[0] = ((cl_short*) in)[0]; }
static void short2uint( void *out, void *in){ ((cl_uint*) out)[0] = ((cl_short*) in)[0]; }
static void short2int( void *out, void *in){ ((cl_int*) out)[0] = ((cl_short*) in)[0]; }
static void short2float( void *out, void *in)
{
    cl_short l = ((cl_short*) in)[0];
    ((float*) out)[0] = (l == 0 ? 0.0f : (float) l);        // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
}
static void short2double( void *out, void *in)
{
    cl_short l = ((cl_short*) in)[0];
    ((double*) out)[0] = (l == 0 ? 0.0 : (double) l);      // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
}
static void short2ulong( void *out, void *in){ ((cl_ulong*) out)[0] = ((cl_short*) in)[0]; }
static void short2long( void *out, void *in){ ((cl_long*) out)[0] = ((cl_short*) in)[0]; }
static void uint2uchar( void *out, void *in){ ((cl_uchar*) out)[0] = ((cl_uint*) in)[0]; }
static void uint2char( void *out, void *in){ ((cl_char*) out)[0] = ((cl_uint*) in)[0]; }
static void uint2ushort( void *out, void *in){ ((cl_ushort*) out)[0] = ((cl_uint*) in)[0]; }
static void uint2short( void *out, void *in){ ((short*) out)[0] = ((cl_uint*) in)[0]; }
static void uint2int( void *out, void *in){ ((cl_int*) out)[0] = ((cl_uint*) in)[0]; }
static void uint2float( void *out, void *in)
{
    cl_uint l = ((cl_uint*) in)[0];
    ((float*) out)[0] = (l == 0 ? 0.0f : (float) l);        // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
}
static void uint2double( void *out, void *in)
{
    cl_uint l = ((cl_uint*) in)[0];
    ((double*) out)[0] = (l == 0 ? 0.0 : (double) l);      // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
}
static void uint2ulong( void *out, void *in){ ((cl_ulong*) out)[0] = ((cl_uint*) in)[0]; }
static void uint2long( void *out, void *in){ ((cl_long*) out)[0] = ((cl_uint*) in)[0]; }
static void int2uchar( void *out, void *in){ ((cl_uchar*) out)[0] = ((cl_int*) in)[0]; }
static void int2char( void *out, void *in){ ((cl_char*) out)[0] = ((cl_int*) in)[0]; }
static void int2ushort( void *out, void *in){ ((cl_ushort*) out)[0] = ((cl_int*) in)[0]; }
static void int2short( void *out, void *in){ ((cl_short*) out)[0] = ((cl_int*) in)[0]; }
static void int2uint( void *out, void *in){ ((cl_uint*) out)[0] = ((cl_int*) in)[0]; }
static void int2float( void *out, void *in)
{
    cl_int l = ((cl_int*) in)[0];
    ((float*) out)[0] = (l == 0 ? 0.0f : (float) l);        // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
}
static void int2double( void *out, void *in)
{
    cl_int l = ((cl_int*) in)[0];
    ((double*) out)[0] = (l == 0 ? 0.0 : (double) l);      // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
}
static void int2ulong( void *out, void *in){ ((cl_ulong*) out)[0] = ((cl_int*) in)[0]; }
static void int2long( void *out, void *in){ ((cl_long*) out)[0] = ((cl_int*) in)[0]; }
static void float2uchar( void *out, void *in){ ((cl_uchar*) out)[0] = my_rintf(((cl_float*) in)[0]); }
static void float2char( void *out, void *in){ ((cl_char*) out)[0] = my_rintf(((cl_float*) in)[0]); }
static void float2ushort( void *out, void *in){ ((cl_ushort*) out)[0] = my_rintf(((cl_float*) in)[0]); }
static void float2short( void *out, void *in){ ((cl_short*) out)[0] = my_rintf(((cl_float*) in)[0]); }
static void float2uint( void *out, void *in){ ((cl_uint*) out)[0] = my_rintf(((cl_float*) in)[0]); }
static void float2int( void *out, void *in){ ((cl_int*) out)[0] = my_rintf(((cl_float*) in)[0]); }
static void float2double( void *out, void *in){ ((cl_double*) out)[0] = ((cl_float*) in)[0]; }
static void float2ulong( void *out, void *in)
{
#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
    // VS2005 (at least) on x86 uses fistp to store the float as a 64-bit int.
    // However, fistp stores it as a signed int, and some of the test values won't
    // fit into a signed int. (These test values are >= 2^63.) The result on VS2005
    // is that these end up silently (at least by default settings) clamped to
    // the max lowest ulong.
    cl_float x = my_rintf(((cl_float *)in)[0]);
    if (x >= 9223372036854775808.0f) {
        x -= 9223372036854775808.0f;
        ((cl_ulong*) out)[0] = x;
        ((cl_ulong*) out)[0] += 9223372036854775808ULL;
    } else {
        ((cl_ulong*) out)[0] = x;
    }
#else
    ((cl_ulong*) out)[0] = my_rintf(((cl_float*) in)[0]);
#endif
}

static void float2long( void *out, void *in){ ((cl_long*) out)[0] =  llrint_clamped( ((cl_float*) in)[0] ); }
static void double2uchar( void *out, void *in){ ((cl_uchar*) out)[0] = rint(((cl_double*) in)[0]); }
static void double2char( void *out, void *in){ ((cl_char*) out)[0] = rint(((cl_double*) in)[0]); }
static void double2ushort( void *out, void *in){ ((cl_ushort*) out)[0] = rint(((cl_double*) in)[0]); }
static void double2short( void *out, void *in){ ((cl_short*) out)[0] = rint(((cl_double*) in)[0]); }
static void double2uint( void *out, void *in){ ((cl_uint*) out)[0] = (cl_uint) rint(((cl_double*) in)[0]); }
static void double2int( void *out, void *in){ ((cl_int*) out)[0] = (int) rint(((cl_double*) in)[0]); }
static void double2float( void *out, void *in){ ((cl_float*) out)[0] = (float) ((cl_double*) in)[0]; }
static void double2ulong( void *out, void *in){ ((cl_ulong*) out)[0] = (cl_ulong) rint(((cl_double*) in)[0]); }
static void double2long( void *out, void *in){ ((cl_long*) out)[0] = (cl_long) rint(((cl_double*) in)[0]); }
static void ulong2uchar( void *out, void *in){ ((cl_uchar*) out)[0] = (cl_uchar) ((cl_ulong*) in)[0]; }
static void ulong2char( void *out, void *in){ ((cl_char*) out)[0] = (cl_char) ((cl_ulong*) in)[0]; }
static void ulong2ushort( void *out, void *in){ ((cl_ushort*) out)[0] = (cl_ushort) ((cl_ulong*) in)[0]; }
static void ulong2short( void *out, void *in){ ((cl_short*) out)[0] = (cl_short)((cl_ulong*) in)[0]; }
static void ulong2uint( void *out, void *in){ ((cl_uint*) out)[0] = (cl_uint) ((cl_ulong*) in)[0]; }
static void ulong2int( void *out, void *in){ ((cl_int*) out)[0] = (cl_int) ((cl_ulong*) in)[0]; }
static void ulong2float( void *out, void *in)
{
#if defined(_MSC_VER) && defined(_M_X64)
    cl_ulong l = ((cl_ulong*) in)[0];
    float result;
    cl_long sl = ((cl_long)l < 0) ? (cl_long)((l >> 1) | (l & 1)) : (cl_long)l;
    _mm_store_ss(&result, _mm_cvtsi64_ss(_mm_setzero_ps(), sl));
    ((float*) out)[0] = (l == 0 ? 0.0f : (((cl_long)l < 0) ? result * 2.0f : result));
#else
    cl_ulong l = ((cl_ulong*) in)[0];
#if (defined(__arm__) || defined(__aarch64__)) && defined(__GNUC__)
    /* ARM VFP doesn't have hardware instruction for converting from 64-bit
     * integer to float types, hence GCC ARM uses the floating-point emulation
     * code despite which -mfloat-abi setting it is. But the emulation code in
     * libgcc.a has only one rounding mode (round to nearest even in this case)
     * and ignores the user rounding mode setting in hardware.
     * As a result setting rounding modes in hardware won't give correct
     * rounding results for type covert from 64-bit integer to float using GCC
     * for ARM compiler so for testing different rounding modes, we need to use
     * alternative reference function. ARM64 does have an instruction, however
     * we cannot guarantee the compiler will use it.  On all ARM architechures
     * use emulation to calculate reference.*/
    ((float*) out)[0] = qcom_u64_2_f32(l, qcom_sat, qcom_rm);
#else
    ((float*) out)[0] = (l == 0 ? 0.0f : (float) l);        // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
#endif
#endif
}
static void ulong2double( void *out, void *in)
{
#if defined(_MSC_VER)
    cl_ulong l = ((cl_ulong*) in)[0];
    double result;

    cl_long sl = ((cl_long)l < 0) ? (cl_long)((l >> 1) | (l & 1)) : (cl_long)l;
#if defined(_M_X64)
    _mm_store_sd(&result, _mm_cvtsi64_sd(_mm_setzero_pd(), sl));
#else
    result = sl;
#endif
    ((double*) out)[0] = (l == 0 ? 0.0 : (((cl_long)l < 0) ? result * 2.0 : result));
#else
    cl_ulong l = ((cl_ulong*) in)[0];
    ((double*) out)[0] = (l == 0 ? 0.0 : (double) l);      // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
#endif
}
static void ulong2long( void *out, void *in){ ((cl_long*) out)[0] = ((cl_ulong*) in)[0]; }
static void long2uchar( void *out, void *in){ ((cl_uchar*) out)[0] = (cl_uchar) ((cl_long*) in)[0]; }
static void long2char( void *out, void *in){ ((cl_char*) out)[0] = (cl_char) ((cl_long*) in)[0]; }
static void long2ushort( void *out, void *in){ ((cl_ushort*) out)[0] = (cl_ushort) ((cl_long*) in)[0]; }
static void long2short( void *out, void *in){ ((cl_short*) out)[0] = (cl_short) ((cl_long*) in)[0]; }
static void long2uint( void *out, void *in){ ((cl_uint*) out)[0] = (cl_uint) ((cl_long*) in)[0]; }
static void long2int( void *out, void *in){ ((cl_int*) out)[0] = (cl_int) ((cl_long*) in)[0]; }
static void long2float( void *out, void *in)
{
#if defined(_MSC_VER) && defined(_M_X64)
    cl_long l = ((cl_long*) in)[0];
    float result;

    _mm_store_ss(&result, _mm_cvtsi64_ss(_mm_setzero_ps(), l));
    ((float*) out)[0] = (l == 0 ? 0.0f : result);        // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
#else
    cl_long l = ((cl_long*) in)[0];
#if (defined(__arm__) || defined(__aarch64__)) && defined(__GNUC__)
    /* ARM VFP doesn't have hardware instruction for converting from 64-bit
     * integer to float types, hence GCC ARM uses the floating-point emulation
     * code despite which -mfloat-abi setting it is. But the emulation code in
     * libgcc.a has only one rounding mode (round to nearest even in this case)
     * and ignores the user rounding mode setting in hardware.
     * As a result setting rounding modes in hardware won't give correct
     * rounding results for type covert from 64-bit integer to float using GCC
     * for ARM compiler so for testing different rounding modes, we need to use
     * alternative reference function. ARM64 does have an instruction, however
     * we cannot guarantee the compiler will use it.  On all ARM architechures
     * use emulation to calculate reference.*/
    ((float*) out)[0] = (l == 0 ? 0.0f : qcom_s64_2_f32(l, qcom_sat, qcom_rm));
#else
    ((float*) out)[0] = (l == 0 ? 0.0f : (float) l);        // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
#endif
#endif
}
static void long2double( void *out, void *in)
{
#if defined(_MSC_VER) && defined(_M_X64)
    cl_long l = ((cl_long*) in)[0];
    double result;

    _mm_store_sd(&result, _mm_cvtsi64_sd(_mm_setzero_pd(), l));
    ((double*) out)[0] = (l == 0 ? 0.0 : result);        // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
#else
    cl_long l = ((cl_long*) in)[0];
    ((double*) out)[0] = (l == 0 ? 0.0 : (double) l);      // Per IEEE-754-2008 5.4.1, 0's always convert to +0.0
#endif
}
static void long2ulong( void *out, void *in){ ((cl_ulong*) out)[0] = ((cl_long*) in)[0]; }

#define CLAMP( _lo, _x, _hi )   ( (_x) < (_lo) ? (_lo) : ((_x) > (_hi) ? (_hi) : (_x)))

// Done by hand
static void uchar2char_sat( void *out, void *in){ cl_uchar c = ((cl_uchar*) in)[0]; ((cl_char*) out)[0] = c > 0x7f ? 0x7f : c; }
static void uchar2ushort_sat( void *out, void *in){ ((cl_ushort*) out)[0] = ((cl_uchar*) in)[0]; }
static void uchar2short_sat( void *out, void *in){ ((cl_short*) out)[0] = ((cl_uchar*) in)[0]; }
static void uchar2uint_sat( void *out, void *in){ ((cl_uint*) out)[0] = ((cl_uchar*) in)[0]; }
static void uchar2int_sat( void *out, void *in){ ((cl_int*) out)[0] = ((cl_uchar*) in)[0]; }
static void uchar2float_sat( void *out, void *in){ ((cl_float*) out)[0] = my_fabsf( (cl_float) ((cl_uchar*) in)[0]); } // my_fabs workaround for <rdar://problem/5965527>
static void uchar2double_sat( void *out, void *in){ ((cl_double*) out)[0] = my_fabs( (cl_double) ((cl_uchar*) in)[0]); } // my_fabs workaround for <rdar://problem/5965527>
static void uchar2ulong_sat( void *out, void *in){ ((cl_ulong*) out)[0] = ((cl_uchar*) in)[0]; }
static void uchar2long_sat( void *out, void *in){ ((cl_long*) out)[0] = ((cl_uchar*) in)[0]; }
static void char2uchar_sat( void *out, void *in){ cl_char c = ((cl_char*) in)[0]; ((cl_uchar*) out)[0] = c < 0 ? 0 : c; }
static void char2ushort_sat( void *out, void *in){ cl_char c = ((cl_char*) in)[0]; ((cl_ushort*) out)[0] = c < 0 ? 0 : c; }
static void char2short_sat( void *out, void *in){ ((cl_short*) out)[0] = ((cl_char*) in)[0]; }
static void char2uint_sat( void *out, void *in){ cl_char c = ((cl_char*) in)[0]; ((cl_uint*) out)[0] = c < 0 ? 0 : c; }
static void char2int_sat( void *out, void *in){ ((cl_int*) out)[0] = ((cl_char*) in)[0]; }
static void char2float_sat( void *out, void *in){ ((cl_float*) out)[0] = ((cl_char*) in)[0]; }
static void char2double_sat( void *out, void *in){ ((cl_double*) out)[0] = ((cl_char*) in)[0]; }
static void char2ulong_sat( void *out, void *in){ cl_char c = ((cl_char*) in)[0]; ((cl_ulong*) out)[0] = c < 0 ? 0 : c; }
static void char2long_sat( void *out, void *in){ ((cl_long*) out)[0] = ((cl_char*) in)[0]; }
static void ushort2uchar_sat( void *out, void *in){ cl_ushort u = ((cl_ushort*) in)[0]; ((cl_uchar*) out)[0] = u > 0xff ? 0xFF : u; }
static void ushort2char_sat( void *out, void *in){ cl_ushort u = ((cl_ushort*) in)[0]; ((cl_char*) out)[0] = u > 0x7f ? 0x7F : u; }
static void ushort2short_sat( void *out, void *in){ cl_ushort u = ((cl_ushort*) in)[0]; ((cl_short*) out)[0] = u > 0x7fff ? 0x7fFF : u; }
static void ushort2uint_sat( void *out, void *in){ ((cl_uint*) out)[0] = ((cl_ushort*) in)[0]; }
static void ushort2int_sat( void *out, void *in){ ((cl_int*) out)[0] = ((cl_ushort*) in)[0]; }
static void ushort2float_sat( void *out, void *in){ ((cl_float*) out)[0] = my_fabsf((cl_float)((cl_ushort*) in)[0]); }     // my_fabs workaround for <rdar://problem/5965527>
static void ushort2double_sat( void *out, void *in){ ((cl_double*) out)[0] = my_fabs( (cl_double) ((cl_ushort*) in)[0]); } // my_fabs workaround for <rdar://problem/5965527>
static void ushort2ulong_sat( void *out, void *in){ ((cl_ulong*) out)[0] = ((cl_ushort*) in)[0]; }
static void ushort2long_sat( void *out, void *in){ ((cl_long*) out)[0] = ((cl_ushort*) in)[0]; }
static void short2uchar_sat( void *out, void *in){ cl_short s = ((cl_short*) in)[0]; ((cl_uchar*) out)[0] = CLAMP( 0, s, CL_UCHAR_MAX ); }
static void short2char_sat( void *out, void *in){ cl_short s = ((cl_short*) in)[0]; ((cl_char*) out)[0] = CLAMP( CL_CHAR_MIN, s, CL_CHAR_MAX ); }
static void short2ushort_sat( void *out, void *in){ cl_short s = ((cl_short*) in)[0]; ((cl_ushort*) out)[0] = s < 0 ? 0 : s; }
static void short2uint_sat( void *out, void *in){ cl_short s = ((cl_short*) in)[0]; ((cl_uint*) out)[0] = s < 0 ? 0 : s; }
static void short2int_sat( void *out, void *in){ ((cl_int*) out)[0] = ((cl_short*) in)[0]; }
static void short2float_sat( void *out, void *in){ ((cl_float*) out)[0] = ((cl_short*) in)[0]; }
static void short2double_sat( void *out, void *in){ ((cl_double*) out)[0] = ((cl_short*) in)[0]; }
static void short2ulong_sat( void *out, void *in){ cl_short s = ((cl_short*) in)[0]; ((cl_ulong*) out)[0] = s < 0 ? 0 : s; }
static void short2long_sat( void *out, void *in){ ((cl_long*) out)[0] = ((cl_short*) in)[0]; }
static void uint2uchar_sat( void *out, void *in){ cl_uint u = ((cl_uint*) in)[0]; ((cl_uchar*) out)[0] = CLAMP( 0, u, CL_UCHAR_MAX); }
static void uint2char_sat( void *out, void *in){  cl_uint u = ((cl_uint*) in)[0]; ((cl_char*) out)[0] = CLAMP( 0, u, CL_CHAR_MAX ); }
static void uint2ushort_sat( void *out, void *in){  cl_uint u = ((cl_uint*) in)[0]; ((cl_ushort*) out)[0] = CLAMP( 0, u, CL_USHRT_MAX); }
static void uint2short_sat( void *out, void *in){  cl_uint u = ((cl_uint*) in)[0]; ((cl_short*) out)[0] = CLAMP( 0, u, CL_SHRT_MAX); }
static void uint2int_sat( void *out, void *in){  cl_uint u = ((cl_uint*) in)[0]; ((cl_int*) out)[0] = CLAMP( 0, u, CL_INT_MAX); }
static void uint2float_sat( void *out, void *in){ ((cl_float*) out)[0] = my_fabsf( (cl_float) ((cl_uint*) in)[0] ); }  // my_fabs workaround for <rdar://problem/5965527>
static void uint2double_sat( void *out, void *in){ ((cl_double*) out)[0] = my_fabs( (cl_double) ((cl_uint*) in)[0]); } // my_fabs workaround for <rdar://problem/5965527>
static void uint2ulong_sat( void *out, void *in){ ((cl_ulong*) out)[0] = ((cl_uint*) in)[0]; }
static void uint2long_sat( void *out, void *in){ ((cl_long*) out)[0] = ((cl_uint*) in)[0]; }
static void int2uchar_sat( void *out, void *in){ cl_int i = ((cl_int*) in)[0]; ((cl_uchar*) out)[0] = CLAMP( 0, i, CL_UCHAR_MAX); }
static void int2char_sat( void *out, void *in){ cl_int i = ((cl_int*) in)[0]; ((cl_char*) out)[0] = CLAMP( CL_CHAR_MIN, i, CL_CHAR_MAX); }
static void int2ushort_sat( void *out, void *in){ cl_int i = ((cl_int*) in)[0]; ((cl_ushort*) out)[0] = CLAMP( 0, i, CL_USHRT_MAX); }
static void int2short_sat( void *out, void *in){ cl_int i = ((cl_int*) in)[0]; ((cl_short*) out)[0] = CLAMP( CL_SHRT_MIN, i, CL_SHRT_MAX); }
static void int2uint_sat( void *out, void *in){ cl_int i = ((cl_int*) in)[0]; ((cl_uint*) out)[0] = CLAMP( 0, i, CL_INT_MAX); }
static void int2float_sat( void *out, void *in){ ((cl_float*) out)[0] = ((cl_int*) in)[0]; }
static void int2double_sat( void *out, void *in){ ((cl_double*) out)[0] = ((cl_int*) in)[0]; }
static void int2ulong_sat( void *out, void *in){ cl_int i = ((cl_int*) in)[0]; ((cl_ulong*) out)[0] = i < 0 ? 0 : i; }
static void int2long_sat( void *out, void *in){ ((cl_long*) out)[0] = ((cl_int*) in)[0]; }
static void float2uchar_sat( void *out, void *in){ ((cl_uchar*) out)[0] = CLAMP( 0, lrintf_clamped(((cl_float*) in)[0]), CL_UCHAR_MAX ); }
static void float2char_sat( void *out, void *in){ ((cl_char*) out)[0] = CLAMP( CL_CHAR_MIN, lrintf_clamped(((cl_float*) in)[0]), CL_CHAR_MAX); }
static void float2ushort_sat( void *out, void *in){ ((cl_ushort*) out)[0] = CLAMP( 0, lrintf_clamped(((cl_float*) in)[0]), CL_USHRT_MAX ); }
static void float2short_sat( void *out, void *in){ ((cl_short*) out)[0] = CLAMP( CL_SHRT_MIN, lrintf_clamped(((cl_float*) in)[0]), CL_SHRT_MAX ); }
static void float2uint_sat( void *out, void *in){ ((cl_uint*) out)[0] = (cl_uint) CLAMP( 0, llrintf_clamped(((cl_float*) in)[0]), CL_UINT_MAX ); }
static void float2int_sat( void *out, void *in){ ((cl_int*) out)[0] = (cl_int) CLAMP( CL_INT_MIN, lrintf_clamped(((cl_float*) in)[0]), CL_INT_MAX ); }
static void float2double_sat( void *out, void *in){ ((cl_double*) out)[0] = ((cl_float*) in)[0]; }
static void float2ulong_sat( void *out, void *in)
{
#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
    // VS2005 (at least) on x86 uses fistp to store the float as a 64-bit int.
    // However, fistp stores it as a signed int, and some of the test values won't
    // fit into a signed int. (These test values are >= 2^63.) The result on VS2005
    // is that these end up silently (at least by default settings) clamped to
    // the max lowest ulong.
    cl_float x = my_rintf(((cl_float *)in)[0]);
    if (x >= 18446744073709551616.0f) {         // 2^64
        ((cl_ulong*) out)[0] = 0xFFFFFFFFFFFFFFFFULL;
    } else if (x < 0) {
        ((cl_ulong*) out)[0] = 0;
    } else if (x >= 9223372036854775808.0f) {   // 2^63
        x -= 9223372036854775808.0f;
        ((cl_ulong*) out)[0] = x;
        ((cl_ulong*) out)[0] += 9223372036854775808ULL;
    } else {
        ((cl_ulong*) out)[0] = x;
    }
#else
    float f = my_rintf(((float*) in)[0]); ((cl_ulong*) out)[0] = f >= MAKE_HEX_DOUBLE(0x1.0p64, 0x1LL, 64) ? 0xFFFFFFFFFFFFFFFFULL : f < 0 ? 0 : (cl_ulong) f;
#endif
}
// The final cast used to be (cl_ulong) f, but on Linux (RHEL5 at least)
// if f = -1.0f, then (cl_ulong) f = 0xffffffff, which clearly isn't right.
// Switching it to (cl_long) f seems to fix that.
static void float2long_sat( void *out, void *in){ float f = my_rintf(((float*) in)[0]); ((cl_long*) out)[0] = f >= MAKE_HEX_DOUBLE(0x1.0p63, 0x1LL, 63) ? 0x7FFFFFFFFFFFFFFFULL : f < MAKE_HEX_DOUBLE(-0x1.0p63, -0x1LL, 63) ? 0x8000000000000000LL : (cl_long) f; }
static void double2uchar_sat( void *out, void *in){ ((cl_uchar*) out)[0] = CLAMP( 0, lrint_clamped(((cl_double*) in)[0]), CL_UCHAR_MAX ); }
static void double2char_sat( void *out, void *in){ ((cl_char*) out)[0] = CLAMP( CL_CHAR_MIN, lrint_clamped(((cl_double*) in)[0]), CL_CHAR_MAX); }
static void double2ushort_sat( void *out, void *in){ ((cl_ushort*) out)[0] = CLAMP( 0, lrint_clamped(((cl_double*) in)[0]), CL_USHRT_MAX ); }
static void double2short_sat( void *out, void *in){ ((cl_short*) out)[0] = CLAMP( CL_SHRT_MIN, lrint_clamped(((cl_double*) in)[0]), CL_SHRT_MAX ); }
static void double2uint_sat( void *out, void *in){ ((cl_uint*) out)[0] = (cl_uint) CLAMP( 0, llrint_clamped(((cl_double*) in)[0]), CL_UINT_MAX ); }
static void double2int_sat( void *out, void *in){ ((cl_int*) out)[0] = (cl_int) CLAMP( CL_INT_MIN, lrint_clamped(((cl_double*) in)[0]), CL_INT_MAX ); }
static void double2float_sat( void *out, void *in){ ((cl_float*) out)[0] = (cl_float) ((double*) in)[0]; }
static void double2ulong_sat( void *out, void *in){ double f = rint(((double*) in)[0]); ((cl_ulong*) out)[0] = f >= MAKE_HEX_DOUBLE(0x1.0p64, 0x1LL, 64) ? 0xFFFFFFFFFFFFFFFFULL : f < 0 ? 0 : (cl_ulong) f; }
static void double2long_sat( void *out, void *in){ double f = rint(((double*) in)[0]); ((cl_long*) out)[0] = f >= MAKE_HEX_DOUBLE(0x1.0p63, 0x1LL, 63) ? 0x7FFFFFFFFFFFFFFFULL : f < MAKE_HEX_DOUBLE(-0x1.0p63, -0x1LL, 63) ? 0x8000000000000000LL : (cl_long) f; }
static void ulong2uchar_sat( void *out, void *in){ cl_ulong u = ((cl_ulong*) in)[0]; ((cl_uchar*) out)[0] = CLAMP( 0, u, CL_UCHAR_MAX ); }
static void ulong2char_sat( void *out, void *in){ cl_ulong u = ((cl_ulong*) in)[0]; ((cl_char*) out)[0] = CLAMP( 0, u, CL_CHAR_MAX ); }
static void ulong2ushort_sat( void *out, void *in){ cl_ulong u = ((cl_ulong*) in)[0]; ((cl_ushort*) out)[0] = CLAMP( 0, u, CL_USHRT_MAX ); }
static void ulong2short_sat( void *out, void *in){ cl_ulong u = ((cl_ulong*) in)[0]; ((cl_short*) out)[0] = CLAMP( 0, u, CL_SHRT_MAX ); }
static void ulong2uint_sat( void *out, void *in){ cl_ulong u = ((cl_ulong*) in)[0]; ((cl_uint*) out)[0] = (cl_uint) CLAMP( 0, u, CL_UINT_MAX ); }
static void ulong2int_sat( void *out, void *in){ cl_ulong u = ((cl_ulong*) in)[0]; ((cl_int*) out)[0] = (cl_int) CLAMP( 0, u, CL_INT_MAX ); }
static void ulong2float_sat( void *out, void *in){ ((float*) out)[0] = my_fabsf((float) ((cl_ulong*) in)[0]); }  // my_fabs workaround for <rdar://problem/5965527>
static void ulong2double_sat( void *out, void *in){ ((double*) out)[0] = my_fabs( ((cl_ulong*) in)[0]); }        // my_fabs workaround for <rdar://problem/5965527>
static void ulong2long_sat( void *out, void *in){ cl_ulong u = ((cl_ulong*) in)[0]; ((cl_long*) out)[0] = CLAMP( 0, u, CL_LONG_MAX ); }
static void long2uchar_sat( void *out, void *in){ cl_long u = ((cl_long*) in)[0]; ((cl_uchar*) out)[0] = CLAMP( 0, u, CL_UCHAR_MAX ); }
static void long2char_sat( void *out, void *in){ cl_long u = ((cl_long*) in)[0]; ((cl_char*) out)[0] = CLAMP( CL_CHAR_MIN, u, CL_CHAR_MAX ); }
static void long2ushort_sat( void *out, void *in){ cl_long u = ((cl_long*) in)[0]; ((cl_ushort*) out)[0] = CLAMP( 0, u, CL_USHRT_MAX ); }
static void long2short_sat( void *out, void *in){ cl_long u = ((cl_long*) in)[0]; ((cl_short*) out)[0] = CLAMP( CL_SHRT_MIN, u, CL_SHRT_MAX ); }
static void long2uint_sat( void *out, void *in){ cl_long u = ((cl_long*) in)[0]; ((cl_uint*) out)[0] = (cl_uint) CLAMP( 0, u, CL_UINT_MAX ); }
static void long2int_sat( void *out, void *in){ cl_long u = ((cl_long*) in)[0]; ((cl_int*) out)[0] = (int) CLAMP( CL_INT_MIN, u, CL_INT_MAX ); }
static void long2float_sat( void *out, void *in){ ((float*) out)[0] = (float) ((cl_long*) in)[0]; }
static void long2double_sat( void *out, void *in){ ((double*) out)[0] = ((cl_long*) in)[0]; }
static void long2ulong_sat( void *out, void *in){ cl_long u = ((cl_long*) in)[0]; ((cl_ulong*) out)[0] = CLAMP( 0, u, CL_LONG_MAX ); }

/*
#include <stdio.h>

char *ground[] = {   "",
                                                            "_rte",
                                                            "_rtp",
                                                            "_rtn",
                                                            "_rtz"
                    };

const char *gTypeNames[  ] = {
                                            "uchar", "char",
                                            "ushort", "short",
                                            "uint",   "int",
                                            "float", "double",
                                            "ulong", "long"
                                        };


int main( void )
{
    int i, j;

    for( i = 0; i < sizeof( gTypeNames ) / sizeof( gTypeNames[0] ); i++ )
        for( j = 0; j < sizeof( ground ) / sizeof( ground[0] ); j++ )
        {
            vlog( "float clampf_%s%s( float );\n", gTypeNames[i], ground[j] );
            vlog( "double clampd_%s%s( double );\n", gTypeNames[i], ground[j] );
        }

    return 0;

}
*/


float clampf_uchar( float );
double clampd_uchar( double );
float clampf_uchar_rte( float );
double clampd_uchar_rte( double );
float clampf_uchar_rtp( float );
double clampd_uchar_rtp( double );
float clampf_uchar_rtn( float );
double clampd_uchar_rtn( double );
float clampf_uchar_rtz( float );
double clampd_uchar_rtz( double );
float clampf_char( float );
double clampd_char( double );
float clampf_char_rte( float );
double clampd_char_rte( double );
float clampf_char_rtp( float );
double clampd_char_rtp( double );
float clampf_char_rtn( float );
double clampd_char_rtn( double );
float clampf_char_rtz( float );
double clampd_char_rtz( double );
float clampf_ushort( float );
double clampd_ushort( double );
float clampf_ushort_rte( float );
double clampd_ushort_rte( double );
float clampf_ushort_rtp( float );
double clampd_ushort_rtp( double );
float clampf_ushort_rtn( float );
double clampd_ushort_rtn( double );
float clampf_ushort_rtz( float );
double clampd_ushort_rtz( double );
float clampf_short( float );
double clampd_short( double );
float clampf_short_rte( float );
double clampd_short_rte( double );
float clampf_short_rtp( float );
double clampd_short_rtp( double );
float clampf_short_rtn( float );
double clampd_short_rtn( double );
float clampf_short_rtz( float );
double clampd_short_rtz( double );
float clampf_uint( float );
double clampd_uint( double );
float clampf_uint_rte( float );
double clampd_uint_rte( double );
float clampf_uint_rtp( float );
double clampd_uint_rtp( double );
float clampf_uint_rtn( float );
double clampd_uint_rtn( double );
float clampf_uint_rtz( float );
double clampd_uint_rtz( double );
float clampf_int( float );
double clampd_int( double );
float clampf_int_rte( float );
double clampd_int_rte( double );
float clampf_int_rtp( float );
double clampd_int_rtp( double );
float clampf_int_rtn( float );
double clampd_int_rtn( double );
float clampf_int_rtz( float );
double clampd_int_rtz( double );
float clampf_float( float );
double clampd_float( double );
float clampf_float_rte( float );
double clampd_float_rte( double );
float clampf_float_rtp( float );
double clampd_float_rtp( double );
float clampf_float_rtn( float );
double clampd_float_rtn( double );
float clampf_float_rtz( float );
double clampd_float_rtz( double );
float clampf_double( float );
double clampd_double( double );
float clampf_double_rte( float );
double clampd_double_rte( double );
float clampf_double_rtp( float );
double clampd_double_rtp( double );
float clampf_double_rtn( float );
double clampd_double_rtn( double );
float clampf_double_rtz( float );
double clampd_double_rtz( double );
float clampf_ulong( float );
double clampd_ulong( double );
float clampf_ulong_rte( float );
double clampd_ulong_rte( double );
float clampf_ulong_rtp( float );
double clampd_ulong_rtp( double );
float clampf_ulong_rtn( float );
double clampd_ulong_rtn( double );
float clampf_ulong_rtz( float );
double clampd_ulong_rtz( double );
float clampf_long( float );
double clampd_long( double );
float clampf_long_rte( float );
double clampd_long_rte( double );
float clampf_long_rtp( float );
double clampd_long_rtp( double );
float clampf_long_rtn( float );
double clampd_long_rtn( double );
float clampf_long_rtz( float );
double clampd_long_rtz( double );

/*
#include <stdio.h>

char *ground[] = {   "",
                                                            "_rte",
                                                            "_rtp",
                                                            "_rtn",
                                                            "_rtz"
                    };

const char *gTypeNames[  ] = {
                                            "uchar", "char",
                                            "ushort", "short",
                                            "uint",   "int",
                                            "float", "double",
                                            "ulong", "long"
                                        };


int main( void )
{
    int i, j;

    for( i = 0; i < sizeof( gTypeNames ) / sizeof( gTypeNames[0] ); i++ )
    {
        vlog( "{\t" );
        for( j = 0; j < sizeof( ground ) / sizeof( ground[0] ); j++ )
            vlog( "clampf_%s%s,\t", gTypeNames[i], ground[j] );

        vlog( "\t},\n" );
    }

    return 0;

}
*/
clampf gClampFloat[ kTypeCount ][kRoundingModeCount] = {
    {    clampf_uchar,    clampf_uchar_rte,    clampf_uchar_rtp,    clampf_uchar_rtn,    clampf_uchar_rtz,        },
    {    clampf_char,    clampf_char_rte,    clampf_char_rtp,    clampf_char_rtn,    clampf_char_rtz,        },
    {    clampf_ushort,    clampf_ushort_rte,    clampf_ushort_rtp,    clampf_ushort_rtn,    clampf_ushort_rtz,        },
    {    clampf_short,    clampf_short_rte,    clampf_short_rtp,    clampf_short_rtn,    clampf_short_rtz,        },
    {    clampf_uint,    clampf_uint_rte,    clampf_uint_rtp,    clampf_uint_rtn,    clampf_uint_rtz,        },
    {    clampf_int,     clampf_int_rte,     clampf_int_rtp,     clampf_int_rtn,     clampf_int_rtz,         },
    {    clampf_float,    clampf_float_rte,    clampf_float_rtp,    clampf_float_rtn,    clampf_float_rtz,        },
    {    clampf_double,    clampf_double_rte,    clampf_double_rtp,    clampf_double_rtn,    clampf_double_rtz,        },
    {    clampf_ulong,    clampf_ulong_rte,    clampf_ulong_rtp,    clampf_ulong_rtn,    clampf_ulong_rtz,        },
    {    clampf_long,    clampf_long_rte,    clampf_long_rtp,    clampf_long_rtn,    clampf_long_rtz,        }
};

clampd gClampDouble[ kTypeCount ][kRoundingModeCount] = {
    {    clampd_uchar,    clampd_uchar_rte,    clampd_uchar_rtp,    clampd_uchar_rtn,    clampd_uchar_rtz,        },
    {    clampd_char,    clampd_char_rte,    clampd_char_rtp,    clampd_char_rtn,    clampd_char_rtz,        },
    {    clampd_ushort,    clampd_ushort_rte,    clampd_ushort_rtp,    clampd_ushort_rtn,    clampd_ushort_rtz,        },
    {    clampd_short,    clampd_short_rte,    clampd_short_rtp,    clampd_short_rtn,    clampd_short_rtz,        },
    {    clampd_uint,    clampd_uint_rte,    clampd_uint_rtp,    clampd_uint_rtn,    clampd_uint_rtz,        },
    {    clampd_int,     clampd_int_rte,     clampd_int_rtp,     clampd_int_rtn,     clampd_int_rtz,         },
    {    clampd_float,    clampd_float_rte,    clampd_float_rtp,    clampd_float_rtn,    clampd_float_rtz,        },
    {    clampd_double,    clampd_double_rte,    clampd_double_rtp,    clampd_double_rtn,    clampd_double_rtz,        },
    {    clampd_ulong,    clampd_ulong_rte,    clampd_ulong_rtp,    clampd_ulong_rtn,    clampd_ulong_rtz,        },
    {    clampd_long,    clampd_long_rte,    clampd_long_rtp,    clampd_long_rtn,    clampd_long_rtz,        }
};

#if defined (_WIN32)
#define __attribute__(X)
#endif

static inline float fclamp( float lo, float v, float hi ) __attribute__ ((always_inline));
static inline double dclamp( double lo, double v, double hi ) __attribute__ ((always_inline));

static inline float fclamp( float lo, float v, float hi ){ v = v < lo ? lo : v; return v < hi ? v : hi; }
static inline double dclamp( double lo, double v, double hi ){ v = v < lo ? lo : v; return v < hi ? v : hi; }

// Clamp unsaturated inputs into range so we don't get test errors:
float clampf_uchar( float f )       { return fclamp( -0.5f, f, 255.5f - 128.0f * FLT_EPSILON ); }
double clampd_uchar( double f )     { return dclamp( -0.5, f, 255.5 - 128.0 * DBL_EPSILON ); }
float clampf_uchar_rte( float f )   { return fclamp( -0.5f, f, 255.5f - 128.0f * FLT_EPSILON ); }
double clampd_uchar_rte( double f ) { return dclamp( -0.5, f, 255.5 - 128.0 * DBL_EPSILON ); }
float clampf_uchar_rtp( float f )   { return fclamp( -1.0f + FLT_EPSILON/2.0f, f, 255.0f ); }
double clampd_uchar_rtp( double f ) { return dclamp( -1.0 + DBL_EPSILON/2.0, f, 255.0 ); }
float clampf_uchar_rtn( float f )   { return fclamp( -0.0f, f, 256.0f - 128.0f * FLT_EPSILON); }
double clampd_uchar_rtn( double f ) { return dclamp( -0.0, f, 256.0 - 128.0 * DBL_EPSILON); }
float clampf_uchar_rtz( float f )   { return fclamp( -1.0f + FLT_EPSILON/2.0f, f, 256.0f - 128.0f * FLT_EPSILON); }
double clampd_uchar_rtz( double f ) { return dclamp( -1.0 + DBL_EPSILON/2.0, f, 256.0 - 128.0f * DBL_EPSILON); }

float clampf_char( float f )        { return fclamp( -128.5f, f, 127.5f - 64.f * FLT_EPSILON ); }
double clampd_char( double f )      { return dclamp( -128.5, f, 127.5 - 64. * DBL_EPSILON ); }
float clampf_char_rte( float f )    { return fclamp( -128.5f, f, 127.5f - 64.f * FLT_EPSILON ); }
double clampd_char_rte( double f )  { return dclamp( -128.5, f, 127.5 - 64. * DBL_EPSILON ); }
float clampf_char_rtp( float f )    { return fclamp( -129.0f + 128.f*FLT_EPSILON, f, 127.f ); }
double clampd_char_rtp( double f )  { return dclamp( -129.0 + 128.*DBL_EPSILON, f, 127. ); }
float clampf_char_rtn( float f )    { return fclamp( -128.0f, f, 128.f - 64.0f*FLT_EPSILON ); }
double clampd_char_rtn( double f )  { return dclamp( -128.0, f, 128. - 64.0*DBL_EPSILON ); }
float clampf_char_rtz( float f )    { return fclamp( -129.0f + 128.f*FLT_EPSILON, f, 128.f - 64.0f*FLT_EPSILON ); }
double clampd_char_rtz( double f )  { return dclamp( -129.0 + 128.*DBL_EPSILON, f, 128. - 64.0*DBL_EPSILON ); }

float clampf_ushort( float f )       { return fclamp( -0.5f, f, 65535.5f - 32768.0f * FLT_EPSILON ); }
double clampd_ushort( double f )     { return dclamp( -0.5, f, 65535.5 - 32768.0 * DBL_EPSILON ); }
float clampf_ushort_rte( float f )   { return fclamp( -0.5f, f, 65535.5f - 32768.0f * FLT_EPSILON ); }
double clampd_ushort_rte( double f ) { return dclamp( -0.5, f, 65535.5 - 32768.0 * DBL_EPSILON ); }
float clampf_ushort_rtp( float f )   { return fclamp( -1.0f + FLT_EPSILON/2.0f, f, 65535.0f ); }
double clampd_ushort_rtp( double f ) { return dclamp( -1.0 + DBL_EPSILON/2.0, f, 65535.0 ); }
float clampf_ushort_rtn( float f )   { return fclamp( -0.0f, f, 65536.0f - 32768.0f * FLT_EPSILON); }
double clampd_ushort_rtn( double f ) { return dclamp( -0.0, f, 65536.0 - 32768.0 * DBL_EPSILON); }
float clampf_ushort_rtz( float f )   { return fclamp( -1.0f + FLT_EPSILON/2.0f, f, 65536.0f - 32768.0f * FLT_EPSILON); }
double clampd_ushort_rtz( double f ) { return dclamp( -1.0 + DBL_EPSILON/2.0, f, 65536.0 - 32768.0f * DBL_EPSILON); }

float clampf_short( float f )        { return fclamp( -32768.5f, f, 32767.5f - 16384.f * FLT_EPSILON ); }
double clampd_short( double f )      { return dclamp( -32768.5, f, 32767.5 - 16384. * DBL_EPSILON ); }
float clampf_short_rte( float f )    { return fclamp( -32768.5f, f, 32767.5f - 16384.f * FLT_EPSILON ); }
double clampd_short_rte( double f )  { return dclamp( -32768.5, f, 32767.5 - 16384. * DBL_EPSILON ); }
float clampf_short_rtp( float f )    { return fclamp( -32769.0f + 32768.f*FLT_EPSILON, f, 32767.f ); }
double clampd_short_rtp( double f )  { return dclamp( -32769.0 + 32768.*DBL_EPSILON, f, 32767. ); }
float clampf_short_rtn( float f )    { return fclamp( -32768.0f, f, 32768.f - 16384.0f*FLT_EPSILON ); }
double clampd_short_rtn( double f )  { return dclamp( -32768.0, f, 32768. - 16384.0*DBL_EPSILON ); }
float clampf_short_rtz( float f )    { return fclamp( -32769.0f + 32768.f*FLT_EPSILON, f, 32768.f - 16384.0f*FLT_EPSILON ); }
double clampd_short_rtz( double f )  { return dclamp( -32769.0 + 32768.*DBL_EPSILON, f, 32768. - 16384.0*DBL_EPSILON ); }

float clampf_uint( float f )        { return fclamp( -0.5f, f, MAKE_HEX_FLOAT(0x1.fffffep31f, 0x1fffffeL, 7) ); }
double clampd_uint( double f )      { return dclamp( -0.5, f, CL_UINT_MAX + 0.5 - MAKE_HEX_DOUBLE(0x1.0p31, 0x1LL, 31) * DBL_EPSILON ); }
float clampf_uint_rte( float f )    { return fclamp( -0.5f, f, MAKE_HEX_FLOAT(0x1.fffffep31f, 0x1fffffeL, 7) ); }
double clampd_uint_rte( double f )  { return dclamp( -0.5, f, CL_UINT_MAX + 0.5 - MAKE_HEX_DOUBLE(0x1.0p31, 0x1LL, 31) * DBL_EPSILON ); }
float clampf_uint_rtp( float f )    { return fclamp( -1.0f + FLT_EPSILON/2.0f, f, MAKE_HEX_FLOAT(0x1.fffffep31f, 0x1fffffeL, 7) ); }
double clampd_uint_rtp( double f )  { return dclamp( -1.0 + DBL_EPSILON/2.0, f, CL_UINT_MAX ); }
float clampf_uint_rtn( float f )    { return fclamp( -0.0f, f, MAKE_HEX_FLOAT(0x1.fffffep31f, 0x1fffffeL, 7)); }
double clampd_uint_rtn( double f )  { return dclamp( -0.0, f, MAKE_HEX_DOUBLE(0x1.fffffffffffffp31, 0x1fffffffffffffLL, -21) ); }
float clampf_uint_rtz( float f )    { return fclamp( -1.0f + FLT_EPSILON/2.0f, f, MAKE_HEX_FLOAT(0x1.fffffep31f, 0x1fffffeL, 7)); }
double clampd_uint_rtz( double f )  { return dclamp( -1.0 + DBL_EPSILON/2.0, f, MAKE_HEX_DOUBLE(0x1.fffffffffffffp31, 0x1fffffffffffffLL, -21)); }

float clampf_int( float f )         { return fclamp( INT_MIN, f, MAKE_HEX_FLOAT(0x1.fffffep30f, 0x1fffffeL, 6) ); }
double clampd_int( double f )       { return dclamp( INT_MIN - 0.5, f, CL_INT_MAX + 0.5 - MAKE_HEX_DOUBLE(0x1.0p30, 0x1LL, 30) * DBL_EPSILON ); }
float clampf_int_rte( float f )     { return fclamp( INT_MIN, f, MAKE_HEX_FLOAT(0x1.fffffep30f, 0x1fffffeL, 6) ); }
double clampd_int_rte( double f )   { return dclamp( INT_MIN - 0.5, f, CL_INT_MAX + 0.5 - MAKE_HEX_DOUBLE(0x1.0p30, 0x1LL, 30) * DBL_EPSILON ); }
float clampf_int_rtp( float f )     { return fclamp( INT_MIN, f, MAKE_HEX_FLOAT(0x1.fffffep30f, 0x1fffffeL, 6) ); }
double clampd_int_rtp( double f )   { return dclamp( INT_MIN - 1.0 + DBL_EPSILON * MAKE_HEX_DOUBLE(0x1.0p31, 0x1LL, 31), f, CL_INT_MAX ); }
float clampf_int_rtn( float f )     { return fclamp( INT_MIN, f, MAKE_HEX_FLOAT(0x1.fffffep30f, 0x1fffffeL, 6) ); }
double clampd_int_rtn( double f )   { return dclamp( INT_MIN, f, CL_INT_MAX + 1.0 - MAKE_HEX_DOUBLE(0x1.0p30, 0x1LL, 30) * DBL_EPSILON ); }
float clampf_int_rtz( float f )     { return fclamp( INT_MIN, f, MAKE_HEX_FLOAT(0x1.fffffep30f, 0x1fffffeL, 6) ); }
double clampd_int_rtz( double f )   { return dclamp( INT_MIN - 1.0 + DBL_EPSILON * MAKE_HEX_DOUBLE(0x1.0p31, 0x1LL, 31), f, CL_INT_MAX + 1.0 - MAKE_HEX_DOUBLE(0x1.0p30, 0x1LL, 30) * DBL_EPSILON ); }

float clampf_float( float f ){ return f; }
double clampd_float( double f ){ return f; }
float clampf_float_rte( float f ){ return f; }
double clampd_float_rte( double f ){ return f; }
float clampf_float_rtp( float f ){ return f; }
double clampd_float_rtp( double f ){ return f; }
float clampf_float_rtn( float f ){ return f; }
double clampd_float_rtn( double f ){ return f; }
float clampf_float_rtz( float f ){ return f; }
double clampd_float_rtz( double f ){ return f; }

float clampf_double( float f ){ return f; }
double clampd_double( double f ){ return f; }
float clampf_double_rte( float f ){ return f; }
double clampd_double_rte( double f ){ return f; }
float clampf_double_rtp( float f ){ return f; }
double clampd_double_rtp( double f ){ return f; }
float clampf_double_rtn( float f ){ return f; }
double clampd_double_rtn( double f ){ return f; }
float clampf_double_rtz( float f ){ return f; }
double clampd_double_rtz( double f ){ return f; }

float clampf_ulong( float f )       { return fclamp( -0.5f, f, MAKE_HEX_FLOAT(0x1.fffffep63f, 0x1fffffeL, 39) ); }
double clampd_ulong( double f )     { return dclamp( -0.5, f, MAKE_HEX_DOUBLE(0x1.fffffffffffffp63, 0x1fffffffffffffLL, 11) ); }
float clampf_ulong_rte( float f )   { return fclamp( -0.5f, f, MAKE_HEX_FLOAT(0x1.fffffep63f, 0x1fffffeL, 39) ); }
double clampd_ulong_rte( double f ) { return dclamp( -0.5, f, MAKE_HEX_DOUBLE(0x1.fffffffffffffp63, 0x1fffffffffffffLL, 11) ); }
float clampf_ulong_rtp( float f )   { return fclamp( -1.0f + FLT_EPSILON/2.0f, f, MAKE_HEX_FLOAT(0x1.fffffep63f, 0x1fffffeL, 39) ); }
double clampd_ulong_rtp( double f ) { return dclamp( -1.0 + DBL_EPSILON/2.0, f, MAKE_HEX_DOUBLE(0x1.fffffffffffffp63, 0x1fffffffffffffLL, 11) ); }
float clampf_ulong_rtn( float f )   { return fclamp( -0.0f, f, MAKE_HEX_FLOAT(0x1.fffffep63f, 0x1fffffeL, 39) ); }
double clampd_ulong_rtn( double f ) { return dclamp( -0.0, f, MAKE_HEX_DOUBLE(0x1.fffffffffffffp63, 0x1fffffffffffffLL, 11) ); }
float clampf_ulong_rtz( float f )   { return fclamp( -1.0f + FLT_EPSILON/2.0f, f, MAKE_HEX_FLOAT(0x1.fffffep63f, 0x1fffffeL, 39) ); }
double clampd_ulong_rtz( double f ) { return dclamp( -1.0 + DBL_EPSILON/2.0, f, MAKE_HEX_DOUBLE(0x1.fffffffffffffp63, 0x1fffffffffffffLL, 11) ); }

float clampf_long( float f )        { return fclamp( MAKE_HEX_FLOAT(-0x1.0p63f, -0x1L, 63), f, MAKE_HEX_FLOAT(0x1.fffffep62f, 0x1fffffeL, 38) ); }
double clampd_long( double f )      { return dclamp( MAKE_HEX_DOUBLE(-0x1.0p63, -0x1LL, 63), f, MAKE_HEX_DOUBLE(0x1.fffffffffffffp62, 0x1fffffffffffffLL, 10) ); }
float clampf_long_rte( float f )    { return fclamp( MAKE_HEX_FLOAT(-0x1.0p63f, -0x1L, 63), f, MAKE_HEX_FLOAT(0x1.fffffep62f, 0x1fffffeL, 38) ); }
double clampd_long_rte( double f )  { return dclamp( MAKE_HEX_DOUBLE(-0x1.0p63, -0x1LL, 63), f, MAKE_HEX_DOUBLE(0x1.fffffffffffffp62, 0x1fffffffffffffLL, 10) ); }
float clampf_long_rtp( float f )    { return fclamp( MAKE_HEX_FLOAT(-0x1.0p63f, -0x1L, 63), f, MAKE_HEX_FLOAT(0x1.fffffep62f, 0x1fffffeL, 38) ); }
double clampd_long_rtp( double f )  { return dclamp( MAKE_HEX_DOUBLE(-0x1.0p63, -0x1LL, 63), f, MAKE_HEX_DOUBLE(0x1.fffffffffffffp62, 0x1fffffffffffffLL, 10) ); }
float clampf_long_rtn( float f )    { return fclamp( MAKE_HEX_FLOAT(-0x1.0p63f, -0x1L, 63), f, MAKE_HEX_FLOAT(0x1.fffffep62f, 0x1fffffeL, 38) ); }
double clampd_long_rtn( double f )  { return dclamp( MAKE_HEX_DOUBLE(-0x1.0p63, -0x1LL, 63), f, MAKE_HEX_DOUBLE(0x1.fffffffffffffp62, 0x1fffffffffffffLL, 10) ); }
float clampf_long_rtz( float f )    { return fclamp( MAKE_HEX_FLOAT(-0x1.0p63f, -0x1L, 63), f, MAKE_HEX_FLOAT(0x1.fffffep62f, 0x1fffffeL, 38) ); }
double clampd_long_rtz( double f )  { return dclamp( MAKE_HEX_DOUBLE(-0x1.0p63, -0x1LL, 63), f, MAKE_HEX_DOUBLE(0x1.fffffffffffffp62, 0x1fffffffffffffLL, 10) ); }

#pragma mark -

int alwaysPass( void *out1, void *out2, void *allowZ, uint32_t count, int vectorSize );
int alwaysFail( void *out1, void *out2, void *allowZ, uint32_t count, int vectorSize );
int check_uchar( void *out1, void *out2, void *allowZ, uint32_t count, int vectorSize );
int check_char( void *out1, void *out2, void *allowZ, uint32_t count, int vectorSize );
int check_ushort( void *out1, void *out2, void *allowZ, uint32_t count, int vectorSize );
int check_short( void *out1, void *out2, void *allowZ, uint32_t count, int vectorSize );
int check_uint( void *out1, void *out2, void *allowZ, uint32_t count, int vectorSize );
int check_int( void *out1, void *out2, void *allowZ, uint32_t count, int vectorSize );
int check_ulong( void *out1, void *out2, void *allowZ, uint32_t count, int vectorSize );
int check_long( void *out1, void *out2, void *allowZ, uint32_t count, int vectorSize );
int check_float( void *out1, void *out2, void *allowZ, uint32_t count, int vectorSize );
int check_double( void *out1, void *out2, void *allowZ, uint32_t count, int vectorSize );

void init_uchar( void *dest, SaturationMode, RoundingMode, Type destType, uint64_t start, int count, MTdata d );
void init_char( void *dest, SaturationMode, RoundingMode, Type destType, uint64_t start, int count, MTdata d );
void init_ushort( void *dest, SaturationMode, RoundingMode, Type destType, uint64_t start, int count, MTdata d );
void init_short( void *dest, SaturationMode, RoundingMode, Type destType, uint64_t start, int count, MTdata d );
void init_uint( void *dest, SaturationMode, RoundingMode, Type destType, uint64_t start, int count, MTdata d );
void init_int( void *dest, SaturationMode, RoundingMode, Type destType, uint64_t start, int count, MTdata d );
void init_float( void *dest, SaturationMode, RoundingMode, Type destType, uint64_t start, int count, MTdata d );
void init_double( void *dest, SaturationMode, RoundingMode, Type destType, uint64_t start, int count, MTdata d );
void init_ulong( void *dest, SaturationMode, RoundingMode, Type destType, uint64_t start, int count, MTdata d );
void init_long( void *dest, SaturationMode, RoundingMode, Type destType, uint64_t start, int count, MTdata d );

InitDataFunc gInitFunctions[ kTypeCount ] = {
                                                init_uchar, init_char,
                                                init_ushort, init_short,
                                                init_uint, init_int,
                                                init_float, init_double,
                                                init_ulong, init_long
                                            };


CheckResults gCheckResults[ kTypeCount ] = {
                                                check_uchar, check_char, check_ushort, check_short, check_uint,
                                                check_int, check_float, check_double, check_ulong, check_long
                                            };
#if !defined (__APPLE__)
#define UNUSED
#else
#define UNUSED  __attribute__((unused))
#endif

int alwaysPass( void UNUSED *out1, void UNUSED *out2, void UNUSED *allowZ, uint32_t UNUSED count, int UNUSED vectorSize){ return 0; }
int alwaysFail( void UNUSED *out1, void UNUSED *out2, void UNUSED *allowZ, uint32_t UNUSED count, int UNUSED vectorSize ){ return -1; }

int check_uchar( void *test, void *correct, void *allowZ, uint32_t count, int vectorSize )
{
    const cl_uchar *t = (const cl_uchar*)test;
    const cl_uchar *c = (const cl_uchar*)correct;
    const cl_uchar *a = (const cl_uchar*)allowZ;
    uint32_t i;

    for( i = 0; i < count; i++ )
        if( t[i] != c[i] && !(a[i] != (cl_uchar)0 && t[i] == (cl_uchar)0))
        {
            vlog( "\nError for vector size %d found at 0x%8.8x:  *0x%2.2x vs 0x%2.2x\n", vectorSize, i, c[i], t[i] );
            return i + 1;
        }

    return 0;
}

int check_char( void *test, void *correct, void *allowZ, uint32_t count, int vectorSize )
{
    const cl_char *t = (const cl_char*)test;
    const cl_char *c = (const cl_char*)correct;
    const cl_uchar *a = (const cl_uchar*)allowZ;
    uint32_t i;

    for( i = 0; i < count; i++ )
        if( t[i] != c[i] && !(a[i] != (cl_uchar)0 && t[i] == (cl_char)0))
        {
            vlog( "\nError for vector size %d found at 0x%8.8x:  *0x%2.2x vs 0x%2.2x\n", vectorSize, i, c[i], t[i] );
            return i + 1;
        }

    return 0;
}

int check_ushort( void *test, void *correct, void *allowZ, uint32_t count, int vectorSize )
{
    const cl_ushort *t = (const cl_ushort*)test;
    const cl_ushort *c = (const cl_ushort*)correct;
    const cl_uchar *a = (const cl_uchar*)allowZ;
    uint32_t i;

    for( i = 0; i < count; i++ )
        if( t[i] != c[i] && !(a[i] != (cl_uchar)0 && t[i] == (cl_ushort)0))
        {
            vlog( "\nError for vector size %d found at 0x%8.8x:  *0x%4.4x vs 0x%4.4x\n", vectorSize, i, c[i], t[i] );
            return i + 1;
        }

    return 0;
}

int check_short( void *test, void *correct, void *allowZ, uint32_t count, int vectorSize )
{
    const cl_short *t = (const cl_short*)test;
    const cl_short *c = (const cl_short*)correct;
    const cl_uchar *a = (const cl_uchar*)allowZ;
    uint32_t i;

    for( i = 0; i < count; i++ )
        if( t[i] != c[i] && !(a[i] != (cl_uchar)0 && t[i] == (cl_short)0))
        {
            vlog( "\nError for vector size %d found at 0x%8.8x:  *0x%4.4x vs 0x%4.4x\n", vectorSize, i, c[i], t[i] );
            return i + 1;
        }

    return 0;
}

int check_uint( void *test, void *correct, void *allowZ, uint32_t count, int vectorSize )
{
    const cl_uint *t = (const cl_uint*)test;
    const cl_uint *c = (const cl_uint*)correct;
    const cl_uchar *a = (const cl_uchar*)allowZ;
    uint32_t i;

    for( i = 0; i < count; i++ )
        if( t[i] != c[i] && !(a[i] != (cl_uchar)0 && t[i] == (cl_uint)0))
        {
            vlog( "\nError for vector size %d found at 0x%8.8x:  *0x%8.8x vs 0x%8.8x\n", vectorSize, i, c[i], t[i] );
            return i + 1;
        }

    return 0;
}

int check_int( void *test, void *correct, void *allowZ, uint32_t count, int vectorSize )
{
    const cl_int *t = (const cl_int*)test;
    const cl_int *c = (const cl_int*)correct;
    const cl_uchar *a = (const cl_uchar*)allowZ;
    uint32_t i;

    for( i = 0; i < count; i++ )
        if( t[i] != c[i] && !(a[i] != (cl_uchar)0 && t[i] == (cl_int)0))
        {
            vlog( "\nError for vector size %d found at 0x%8.8x:  *0x%8.8x vs 0x%8.8x\n", vectorSize, i, c[i], t[i] );
            return i + 1;
        }

    return 0;
}

int check_ulong( void *test, void *correct, void *allowZ, uint32_t count, int vectorSize )
{
    const cl_ulong *t = (const cl_ulong*)test;
    const cl_ulong *c = (const cl_ulong*)correct;
    const cl_uchar *a = (const cl_uchar*)allowZ;
    uint32_t i;

    for( i = 0; i < count; i++ )
        if( t[i] != c[i] && !(a[i] != (cl_uchar)0 && t[i] == (cl_ulong)0))
        {
            vlog( "\nError for vector size %d found at 0x%8.8x:  *0x%16.16llx vs 0x%16.16llx\n", vectorSize, i, c[i], t[i] );
            return i + 1;
        }

    return 0;
}

int check_long( void *test, void *correct, void *allowZ, uint32_t count, int vectorSize )
{
    const cl_long *t = (const cl_long*)test;
    const cl_long *c = (const cl_long*)correct;
    const cl_uchar *a = (const cl_uchar*)allowZ;
    uint32_t i;

    for( i = 0; i < count; i++ )
        if( t[i] != c[i] && !(a[i] != (cl_uchar)0 && t[i] == (cl_long)0))
        {
            vlog( "\nError for vector size %d found at 0x%8.8x:  *0x%16.16llx vs 0x%16.16llx\n", vectorSize, i, c[i], t[i] );
            return i + 1;
        }

    return 0;
}

int check_float( void *test, void *correct, void *allowZ, uint32_t count, int vectorSize )
{
    const cl_uint *t = (const cl_uint*)test;
    const cl_uint *c = (const cl_uint*)correct;
    const cl_uchar *a = (const cl_uchar*)allowZ;
    uint32_t i;

    for( i = 0; i < count; i++ )
        if (t[i] != c[i] &&
            // Allow nan's to be binary different
            !((t[i] & 0x7fffffffU) > 0x7f800000U &&
              (c[i] & 0x7fffffffU) > 0x7f800000U) &&
            !(a[i] != (cl_uchar)0 &&
              t[i] == (c[i] & 0x80000000U))) {
            vlog( "\nError for vector size %d found at 0x%8.8x:  *%a vs %a\n",
                    vectorSize, i, ((float*)correct)[i], ((float*)test)[i] );
            return i + 1;
        }

    return 0;
}

int check_double( void *test, void *correct, void *allowZ, uint32_t count, int vectorSize )
{
    const cl_ulong *t = (const cl_ulong*)test;
    const cl_ulong *c = (const cl_ulong*)correct;
    const cl_uchar *a = (const cl_uchar*)allowZ;
    uint32_t i;

    for( i = 0; i < count; i++ )
        if (t[i] != c[i] &&
            // Allow nan's to be binary different
            !((t[i] & 0x7fffffffffffffffULL) > 0x7ff0000000000000ULL &&
              (c[i] & 0x7fffffffffffffffULL) > 0x7f80000000000000ULL) &&
            !(a[i] != (cl_uchar)0 &&
              t[i] == (c[i] & 0x8000000000000000ULL))) {
            vlog( "\nError for vector size %d found at 0x%8.8x:  *%a vs %a\n",
                  vectorSize, i, ((double*)correct)[i], ((double*)test)[i] );
            return i + 1;
        }

    return 0;
}


void init_uchar( void *out, SaturationMode UNUSED sat, RoundingMode UNUSED round, Type UNUSED destType, uint64_t start, int count, MTdata UNUSED d )
{
    cl_uchar *o = (cl_uchar *)out;
    int i;

    for( i = 0; i < count; i++ )
        o[i] = start++;
}

void init_char( void *out, SaturationMode UNUSED sat, RoundingMode UNUSED round, Type UNUSED destType, uint64_t start, int count, MTdata UNUSED d )
{
    char *o = (char *)out;
    int i;

    for( i = 0; i < count; i++ )
        o[i] = start++;
}

void init_ushort( void *out, SaturationMode UNUSED sat, RoundingMode UNUSED round, Type UNUSED destType, uint64_t start, int count, MTdata UNUSED d )
{
    cl_ushort *o = (cl_ushort *)out;
    int i;

    for( i = 0; i < count; i++ )
        o[i] = start++;
}

void init_short( void *out, SaturationMode UNUSED sat, RoundingMode UNUSED round, UNUSED Type destType, uint64_t start, int count, MTdata UNUSED d )
{
    short *o = (short *)out;
    int i;

    for( i = 0; i < count; i++ )
        o[i] = start++;
}

void init_uint( void *out, SaturationMode UNUSED sat, RoundingMode UNUSED round, Type UNUSED destType, uint64_t start, int count, MTdata d )
{
    static const unsigned int specialValuesUInt[] = {
    INT_MIN, INT_MIN + 1, INT_MIN + 2,
    -(1<<30)-3,-(1<<30)-2,-(1<<30)-1, -(1<<30), -(1<<30)+1, -(1<<30)+2, -(1<<30)+3,
    -(1<<24)-3,-(1<<24)-2,-(1<<24)-1, -(1<<24), -(1<<24)+1, -(1<<24)+2, -(1<<24)+3,
    -(1<<23)-3,-(1<<23)-2,-(1<<23)-1, -(1<<23), -(1<<23)+1, -(1<<23)+2, -(1<<23)+3,
    -(1<<22)-3,-(1<<22)-2,-(1<<22)-1, -(1<<22), -(1<<22)+1, -(1<<22)+2, -(1<<22)+3,
    -(1<<21)-3,-(1<<21)-2,-(1<<21)-1, -(1<<21), -(1<<21)+1, -(1<<21)+2, -(1<<21)+3,
    -(1<<16)-3,-(1<<16)-2,-(1<<16)-1, -(1<<16), -(1<<16)+1, -(1<<16)+2, -(1<<16)+3,
    -(1<<15)-3,-(1<<15)-2,-(1<<15)-1, -(1<<15), -(1<<15)+1, -(1<<15)+2, -(1<<15)+3,
    -(1<<8)-3,-(1<<8)-2,-(1<<8)-1, -(1<<8), -(1<<8)+1, -(1<<8)+2, -(1<<8)+3,
    -(1<<7)-3,-(1<<7)-2,-(1<<7)-1, -(1<<7), -(1<<7)+1, -(1<<7)+2, -(1<<7)+3,
    -4, -3, -2, -1, 0, 1, 2, 3, 4,
    (1<<7)-3,(1<<7)-2,(1<<7)-1, (1<<7), (1<<7)+1, (1<<7)+2, (1<<7)+3,
    (1<<8)-3,(1<<8)-2,(1<<8)-1, (1<<8), (1<<8)+1, (1<<8)+2, (1<<8)+3,
    (1<<15)-3,(1<<15)-2,(1<<15)-1, (1<<15), (1<<15)+1, (1<<15)+2, (1<<15)+3,
    (1<<16)-3,(1<<16)-2,(1<<16)-1, (1<<16), (1<<16)+1, (1<<16)+2, (1<<16)+3,
    (1<<21)-3,(1<<21)-2,(1<<21)-1, (1<<21), (1<<21)+1, (1<<21)+2, (1<<21)+3,
    (1<<22)-3,(1<<22)-2,(1<<22)-1, (1<<22), (1<<22)+1, (1<<22)+2, (1<<22)+3,
    (1<<23)-3,(1<<23)-2,(1<<23)-1, (1<<23), (1<<23)+1, (1<<23)+2, (1<<23)+3,
    (1<<24)-3,(1<<24)-2,(1<<24)-1, (1<<24), (1<<24)+1, (1<<24)+2, (1<<24)+3,
    (1<<30)-3,(1<<30)-2,(1<<30)-1, (1<<30), (1<<30)+1, (1<<30)+2, (1<<30)+3,
    INT_MAX-3, INT_MAX-2, INT_MAX-1, INT_MAX, // 0x80000000, 0x80000001 0x80000002 already covered above
    UINT_MAX-3, UINT_MAX-2, UINT_MAX-1, UINT_MAX
    };

    cl_uint *o = (cl_uint *)out;
    int i;

    for( i = 0; i < count; i++) {
    if( gIsEmbedded )
        o[i] = (cl_uint) genrand_int32(d);
    else
        o[i] = (cl_uint)i + start;
    }

    if( 0 == start )
    {
    size_t tableSize = sizeof( specialValuesUInt );
    if( sizeof( cl_uint) * count < tableSize )
        tableSize = sizeof( cl_uint) * count;
    memcpy( (char*)(o + i) - tableSize, specialValuesUInt, tableSize );
    }
}

void init_int( void *out, SaturationMode UNUSED sat, RoundingMode UNUSED round, Type UNUSED destType, uint64_t start, int count, MTdata d )
{
    static const unsigned int specialValuesInt[] = {
    INT_MIN, INT_MIN + 1, INT_MIN + 2,
    -(1<<30)-3,-(1<<30)-2,-(1<<30)-1, -(1<<30), -(1<<30)+1, -(1<<30)+2, -(1<<30)+3,
    -(1<<24)-3,-(1<<24)-2,-(1<<24)-1, -(1<<24), -(1<<24)+1, -(1<<24)+2, -(1<<24)+3,
    -(1<<23)-3,-(1<<23)-2,-(1<<23)-1, -(1<<23), -(1<<23)+1, -(1<<23)+2, -(1<<23)+3,
    -(1<<22)-3,-(1<<22)-2,-(1<<22)-1, -(1<<22), -(1<<22)+1, -(1<<22)+2, -(1<<22)+3,
    -(1<<21)-3,-(1<<21)-2,-(1<<21)-1, -(1<<21), -(1<<21)+1, -(1<<21)+2, -(1<<21)+3,
    -(1<<16)-3,-(1<<16)-2,-(1<<16)-1, -(1<<16), -(1<<16)+1, -(1<<16)+2, -(1<<16)+3,
    -(1<<15)-3,-(1<<15)-2,-(1<<15)-1, -(1<<15), -(1<<15)+1, -(1<<15)+2, -(1<<15)+3,
    -(1<<8)-3,-(1<<8)-2,-(1<<8)-1, -(1<<8), -(1<<8)+1, -(1<<8)+2, -(1<<8)+3,
    -(1<<7)-3,-(1<<7)-2,-(1<<7)-1, -(1<<7), -(1<<7)+1, -(1<<7)+2, -(1<<7)+3,
    -4, -3, -2, -1, 0, 1, 2, 3, 4,
    (1<<7)-3,(1<<7)-2,(1<<7)-1, (1<<7), (1<<7)+1, (1<<7)+2, (1<<7)+3,
    (1<<8)-3,(1<<8)-2,(1<<8)-1, (1<<8), (1<<8)+1, (1<<8)+2, (1<<8)+3,
    (1<<15)-3,(1<<15)-2,(1<<15)-1, (1<<15), (1<<15)+1, (1<<15)+2, (1<<15)+3,
    (1<<16)-3,(1<<16)-2,(1<<16)-1, (1<<16), (1<<16)+1, (1<<16)+2, (1<<16)+3,
    (1<<21)-3,(1<<21)-2,(1<<21)-1, (1<<21), (1<<21)+1, (1<<21)+2, (1<<21)+3,
    (1<<22)-3,(1<<22)-2,(1<<22)-1, (1<<22), (1<<22)+1, (1<<22)+2, (1<<22)+3,
    (1<<23)-3,(1<<23)-2,(1<<23)-1, (1<<23), (1<<23)+1, (1<<23)+2, (1<<23)+3,
    (1<<24)-3,(1<<24)-2,(1<<24)-1, (1<<24), (1<<24)+1, (1<<24)+2, (1<<24)+3,
    (1<<30)-3,(1<<30)-2,(1<<30)-1, (1<<30), (1<<30)+1, (1<<30)+2, (1<<30)+3,
    INT_MAX-3, INT_MAX-2, INT_MAX-1, INT_MAX, // 0x80000000, 0x80000001 0x80000002 already covered above
    UINT_MAX-3, UINT_MAX-2, UINT_MAX-1, UINT_MAX
    };

    int *o = (int *)out;
    int i;

    for( i = 0; i < count; i++ ) {
    if( gIsEmbedded ) {
        o[i] = (int) genrand_int32(d);
    }
    else {
        o[i] = (int) i + start;
    }
    }

    if( 0 == start )
    {
    size_t tableSize = sizeof( specialValuesInt );
    if( sizeof( int) * count < tableSize )
        tableSize = sizeof( int) * count;
    memcpy( (char*)(o + i) - tableSize, specialValuesInt, tableSize );
    }
}

void init_float( void *out, SaturationMode sat, RoundingMode round, Type destType, uint64_t start, int count, MTdata d )
{
    static const float specialValuesFloat[] = {
    -NAN, -INFINITY, -FLT_MAX, MAKE_HEX_FLOAT(-0x1.000002p64f, -0x1000002L, 40), MAKE_HEX_FLOAT(-0x1.0p64f, -0x1L, 64), MAKE_HEX_FLOAT(-0x1.fffffep63f, -0x1fffffeL, 39), MAKE_HEX_FLOAT(-0x1.000002p63f, -0x1000002L, 39), MAKE_HEX_FLOAT(-0x1.0p63f, -0x1L, 63), MAKE_HEX_FLOAT(-0x1.fffffep62f, -0x1fffffeL, 38),
    MAKE_HEX_FLOAT(-0x1.000002p32f, -0x1000002L, 8), MAKE_HEX_FLOAT(-0x1.0p32f, -0x1L, 32), MAKE_HEX_FLOAT(-0x1.fffffep31f, -0x1fffffeL, 7), MAKE_HEX_FLOAT(-0x1.000002p31f, -0x1000002L, 7), MAKE_HEX_FLOAT(-0x1.0p31f, -0x1L, 31), MAKE_HEX_FLOAT(-0x1.fffffep30f, -0x1fffffeL, 6), -1000.f, -100.f, -4.0f, -3.5f,
    -3.0f, MAKE_HEX_FLOAT(-0x1.800002p1f, -0x1800002L, -23), -2.5f, MAKE_HEX_FLOAT(-0x1.7ffffep1f, -0x17ffffeL, -23), -2.0f, MAKE_HEX_FLOAT(-0x1.800002p0f, -0x1800002L, -24), -1.5f, MAKE_HEX_FLOAT(-0x1.7ffffep0f, -0x17ffffeL, -24),MAKE_HEX_FLOAT(-0x1.000002p0f, -0x1000002L, -24), -1.0f, MAKE_HEX_FLOAT(-0x1.fffffep-1f, -0x1fffffeL, -25),
    MAKE_HEX_FLOAT(-0x1.000002p-1f, -0x1000002L, -25), -0.5f, MAKE_HEX_FLOAT(-0x1.fffffep-2f, -0x1fffffeL, -26), MAKE_HEX_FLOAT(-0x1.000002p-2f, -0x1000002L, -26), -0.25f, MAKE_HEX_FLOAT(-0x1.fffffep-3f, -0x1fffffeL, -27),
    MAKE_HEX_FLOAT(-0x1.000002p-126f, -0x1000002L, -150), -FLT_MIN, MAKE_HEX_FLOAT(-0x0.fffffep-126f, -0x0fffffeL, -150), MAKE_HEX_FLOAT(-0x0.000ffep-126f, -0x0000ffeL, -150), MAKE_HEX_FLOAT(-0x0.0000fep-126f, -0x00000feL, -150), MAKE_HEX_FLOAT(-0x0.00000ep-126f, -0x000000eL, -150), MAKE_HEX_FLOAT(-0x0.00000cp-126f, -0x000000cL, -150), MAKE_HEX_FLOAT(-0x0.00000ap-126f, -0x000000aL, -150),
    MAKE_HEX_FLOAT(-0x0.000008p-126f, -0x0000008L, -150), MAKE_HEX_FLOAT(-0x0.000006p-126f, -0x0000006L, -150), MAKE_HEX_FLOAT(-0x0.000004p-126f, -0x0000004L, -150), MAKE_HEX_FLOAT(-0x0.000002p-126f, -0x0000002L, -150), -0.0f,
    +NAN, +INFINITY, +FLT_MAX, MAKE_HEX_FLOAT(+0x1.000002p64f, +0x1000002L, 40), MAKE_HEX_FLOAT(+0x1.0p64f, +0x1L, 64), MAKE_HEX_FLOAT(+0x1.fffffep63f, +0x1fffffeL, 39), MAKE_HEX_FLOAT(+0x1.000002p63f, +0x1000002L, 39), MAKE_HEX_FLOAT(+0x1.0p63f, +0x1L, 63), MAKE_HEX_FLOAT(+0x1.fffffep62f, +0x1fffffeL, 38),
    MAKE_HEX_FLOAT(+0x1.000002p32f, +0x1000002L, 8), MAKE_HEX_FLOAT(+0x1.0p32f, +0x1L, 32), MAKE_HEX_FLOAT(+0x1.fffffep31f, +0x1fffffeL, 7), MAKE_HEX_FLOAT(+0x1.000002p31f, +0x1000002L, 7), MAKE_HEX_FLOAT(+0x1.0p31f, +0x1L, 31), MAKE_HEX_FLOAT(+0x1.fffffep30f, +0x1fffffeL, 6), +1000.f, +100.f, +4.0f, +3.5f,
    +3.0f, MAKE_HEX_FLOAT(+0x1.800002p1f, +0x1800002L, -23), 2.5f, MAKE_HEX_FLOAT(+0x1.7ffffep1f, +0x17ffffeL, -23),+2.0f, MAKE_HEX_FLOAT(+0x1.800002p0f, +0x1800002L, -24), 1.5f, MAKE_HEX_FLOAT(+0x1.7ffffep0f, +0x17ffffeL, -24), MAKE_HEX_FLOAT(+0x1.000002p0f, +0x1000002L, -24), +1.0f, MAKE_HEX_FLOAT(+0x1.fffffep-1f, +0x1fffffeL, -25),
    MAKE_HEX_FLOAT(+0x1.000002p-1f, +0x1000002L, -25), +0.5f, MAKE_HEX_FLOAT(+0x1.fffffep-2f, +0x1fffffeL, -26), MAKE_HEX_FLOAT(+0x1.000002p-2f, +0x1000002L, -26), +0.25f, MAKE_HEX_FLOAT(+0x1.fffffep-3f, +0x1fffffeL, -27),
    MAKE_HEX_FLOAT(0x1.000002p-126f, 0x1000002L, -150), +FLT_MIN, MAKE_HEX_FLOAT(+0x0.fffffep-126f, +0x0fffffeL, -150), MAKE_HEX_FLOAT(+0x0.000ffep-126f, +0x0000ffeL, -150), MAKE_HEX_FLOAT(+0x0.0000fep-126f, +0x00000feL, -150), MAKE_HEX_FLOAT(+0x0.00000ep-126f, +0x000000eL, -150), MAKE_HEX_FLOAT(+0x0.00000cp-126f, +0x000000cL, -150), MAKE_HEX_FLOAT(+0x0.00000ap-126f, +0x000000aL, -150),
    MAKE_HEX_FLOAT(+0x0.000008p-126f, +0x0000008L, -150), MAKE_HEX_FLOAT(+0x0.000006p-126f, +0x0000006L, -150), MAKE_HEX_FLOAT(+0x0.000004p-126f, +0x0000004L, -150), MAKE_HEX_FLOAT(+0x0.000002p-126f, +0x0000002L, -150), +0.0f
    };

    cl_uint *o = (cl_uint *)out;
    int i;

    for( i = 0; i < count; i++ ) {
    if( gIsEmbedded )
        o[i] = (cl_uint) genrand_int32(d);
    else
        o[i] = (cl_uint) i + start;
    }

    if( 0 == start )
    {
    size_t tableSize = sizeof( specialValuesFloat );
    if( sizeof( float) * count < tableSize )
        tableSize = sizeof( float) * count;
    memcpy( (char*)(o + i) - tableSize, specialValuesFloat, tableSize );
    }

    if( kUnsaturated == sat )
    {
        clampf func = gClampFloat[ destType ][round];
        float *f = (float *)out;

        for( i = 0; i < count; i++ )
            f[i] = func( f[i] );
    }
}

// used to convert a bucket of bits into a search pattern through double
static inline double DoubleFromUInt32( uint32_t bits );
static inline double DoubleFromUInt32( uint32_t bits )
{
    union{ uint64_t u; double d;} u;

    // split 0x89abcdef to 0x89abc00000000def
    u.u = bits & 0xfffU;
    u.u |= (uint64_t) (bits & ~0xfffU) << 32;

    // sign extend the leading bit of def segment as sign bit so that the middle region consists of either all 1s or 0s
    u.u -= (bits & 0x800U) << 1;

    // return result
    return u.d;
}

// A table of more difficult cases to get right
static const double specialValuesDouble[] = {
    -NAN, -INFINITY, -DBL_MAX, MAKE_HEX_DOUBLE(-0x1.0000000000001p64, -0x10000000000001LL, 12), MAKE_HEX_DOUBLE(-0x1.0p64, -0x1LL, 64), MAKE_HEX_DOUBLE(-0x1.fffffffffffffp63, -0x1fffffffffffffLL, 11), MAKE_HEX_DOUBLE(-0x1.80000000000001p64, -0x180000000000001LL, 8),
    MAKE_HEX_DOUBLE(-0x1.8p64, -0x18LL, 60), MAKE_HEX_DOUBLE(-0x1.7ffffffffffffp64, -0x17ffffffffffffLL, 12),     MAKE_HEX_DOUBLE(-0x1.80000000000001p63, -0x180000000000001LL, 7), MAKE_HEX_DOUBLE(-0x1.8p63, -0x18LL, 59), MAKE_HEX_DOUBLE(-0x1.7ffffffffffffp63, -0x17ffffffffffffLL, 11),
     MAKE_HEX_DOUBLE(-0x1.0000000000001p63, -0x10000000000001LL, 11), MAKE_HEX_DOUBLE(-0x1.0p63, -0x1LL, 63), MAKE_HEX_DOUBLE(-0x1.fffffffffffffp62, -0x1fffffffffffffLL, 10), MAKE_HEX_DOUBLE(-0x1.80000000000001p32, -0x180000000000001LL, -24), MAKE_HEX_DOUBLE(-0x1.8p32, -0x18LL, 28), MAKE_HEX_DOUBLE(-0x1.7ffffffffffffp32, -0x17ffffffffffffLL, -20),
    MAKE_HEX_DOUBLE(-0x1.000002p32, -0x1000002LL, 8), MAKE_HEX_DOUBLE(-0x1.0p32, -0x1LL, 32), MAKE_HEX_DOUBLE(-0x1.fffffffffffffp31, -0x1fffffffffffffLL, -21), MAKE_HEX_DOUBLE(-0x1.80000000000001p31, -0x180000000000001LL, -25), MAKE_HEX_DOUBLE(-0x1.8p31, -0x18LL, 27), MAKE_HEX_DOUBLE(-0x1.7ffffffffffffp31, -0x17ffffffffffffLL, -21), MAKE_HEX_DOUBLE(-0x1.0000000000001p31, -0x10000000000001LL, -21), MAKE_HEX_DOUBLE(-0x1.0p31, -0x1LL, 31), MAKE_HEX_DOUBLE(-0x1.fffffffffffffp30, -0x1fffffffffffffLL, -22), -1000., -100.,  -4.0, -3.5,
    -3.0, MAKE_HEX_DOUBLE(-0x1.8000000000001p1, -0x18000000000001LL, -51), -2.5, MAKE_HEX_DOUBLE(-0x1.7ffffffffffffp1, -0x17ffffffffffffLL, -51), -2.0, MAKE_HEX_DOUBLE(-0x1.8000000000001p0, -0x18000000000001LL, -52), -1.5, MAKE_HEX_DOUBLE(-0x1.7ffffffffffffp0, -0x17ffffffffffffLL, -52),MAKE_HEX_DOUBLE(-0x1.0000000000001p0, -0x10000000000001LL, -52), -1.0, MAKE_HEX_DOUBLE(-0x1.fffffffffffffp-1, -0x1fffffffffffffLL, -53),
    MAKE_HEX_DOUBLE(-0x1.0000000000001p-1, -0x10000000000001LL, -53), -0.5, MAKE_HEX_DOUBLE(-0x1.fffffffffffffp-2, -0x1fffffffffffffLL, -54),  MAKE_HEX_DOUBLE(-0x1.0000000000001p-2, -0x10000000000001LL, -54), -0.25, MAKE_HEX_DOUBLE(-0x1.fffffffffffffp-3, -0x1fffffffffffffLL, -55),
    MAKE_HEX_DOUBLE(-0x1.0000000000001p-1022, -0x10000000000001LL, -1074), -DBL_MIN, MAKE_HEX_DOUBLE(-0x0.fffffffffffffp-1022, -0x0fffffffffffffLL, -1074), MAKE_HEX_DOUBLE(-0x0.0000000000fffp-1022, -0x00000000000fffLL, -1074), MAKE_HEX_DOUBLE(-0x0.00000000000fep-1022, -0x000000000000feLL, -1074), MAKE_HEX_DOUBLE(-0x0.000000000000ep-1022, -0x0000000000000eLL, -1074), MAKE_HEX_DOUBLE(-0x0.000000000000cp-1022, -0x0000000000000cLL, -1074), MAKE_HEX_DOUBLE(-0x0.000000000000ap-1022, -0x0000000000000aLL, -1074),
    MAKE_HEX_DOUBLE(-0x0.0000000000008p-1022, -0x00000000000008LL, -1074), MAKE_HEX_DOUBLE(-0x0.0000000000007p-1022, -0x00000000000007LL, -1074), MAKE_HEX_DOUBLE(-0x0.0000000000006p-1022, -0x00000000000006LL, -1074), MAKE_HEX_DOUBLE(-0x0.0000000000005p-1022, -0x00000000000005LL, -1074), MAKE_HEX_DOUBLE(-0x0.0000000000004p-1022, -0x00000000000004LL, -1074),
    MAKE_HEX_DOUBLE(-0x0.0000000000003p-1022, -0x00000000000003LL, -1074), MAKE_HEX_DOUBLE(-0x0.0000000000002p-1022, -0x00000000000002LL, -1074), MAKE_HEX_DOUBLE(-0x0.0000000000001p-1022, -0x00000000000001LL, -1074), -0.0,

    MAKE_HEX_DOUBLE(+0x1.fffffffffffffp63, +0x1fffffffffffffLL, 11), MAKE_HEX_DOUBLE(0x1.80000000000001p63, 0x180000000000001LL, 7), MAKE_HEX_DOUBLE(0x1.8p63, 0x18LL, 59), MAKE_HEX_DOUBLE(0x1.7ffffffffffffp63, 0x17ffffffffffffLL, 11),  MAKE_HEX_DOUBLE(+0x1.0000000000001p63, +0x10000000000001LL, 11), MAKE_HEX_DOUBLE(+0x1.0p63, +0x1LL, 63), MAKE_HEX_DOUBLE(+0x1.fffffffffffffp62, +0x1fffffffffffffLL, 10),
     MAKE_HEX_DOUBLE(+0x1.80000000000001p32, +0x180000000000001LL, -24), MAKE_HEX_DOUBLE(+0x1.8p32, +0x18LL, 28), MAKE_HEX_DOUBLE(+0x1.7ffffffffffffp32, +0x17ffffffffffffLL, -20),
    MAKE_HEX_DOUBLE(+0x1.000002p32, +0x1000002LL, 8), MAKE_HEX_DOUBLE(+0x1.0p32, +0x1LL, 32), MAKE_HEX_DOUBLE(+0x1.fffffffffffffp31, +0x1fffffffffffffLL, -21), MAKE_HEX_DOUBLE(+0x1.80000000000001p31, +0x180000000000001LL, -25), MAKE_HEX_DOUBLE(+0x1.8p31, +0x18LL, 27), MAKE_HEX_DOUBLE(+0x1.7ffffffffffffp31, +0x17ffffffffffffLL, -21), MAKE_HEX_DOUBLE(+0x1.0000000000001p31, +0x10000000000001LL, -21), MAKE_HEX_DOUBLE(+0x1.0p31, +0x1LL, 31), MAKE_HEX_DOUBLE(+0x1.fffffffffffffp30, +0x1fffffffffffffLL, -22), +1000., +100.,  +4.0, +3.5,
    +3.0, MAKE_HEX_DOUBLE(+0x1.8000000000001p1, +0x18000000000001LL, -51), +2.5, MAKE_HEX_DOUBLE(+0x1.7ffffffffffffp1, +0x17ffffffffffffLL, -51), +2.0, MAKE_HEX_DOUBLE(+0x1.8000000000001p0, +0x18000000000001LL, -52), +1.5, MAKE_HEX_DOUBLE(+0x1.7ffffffffffffp0, +0x17ffffffffffffLL, -52),MAKE_HEX_DOUBLE(-0x1.0000000000001p0, -0x10000000000001LL, -52), +1.0, MAKE_HEX_DOUBLE(+0x1.fffffffffffffp-1, +0x1fffffffffffffLL, -53),
    MAKE_HEX_DOUBLE(+0x1.0000000000001p-1, +0x10000000000001LL, -53), +0.5, MAKE_HEX_DOUBLE(+0x1.fffffffffffffp-2, +0x1fffffffffffffLL, -54),  MAKE_HEX_DOUBLE(+0x1.0000000000001p-2, +0x10000000000001LL, -54), +0.25, MAKE_HEX_DOUBLE(+0x1.fffffffffffffp-3, +0x1fffffffffffffLL, -55),
    MAKE_HEX_DOUBLE(+0x1.0000000000001p-1022, +0x10000000000001LL, -1074), +DBL_MIN, MAKE_HEX_DOUBLE(+0x0.fffffffffffffp-1022, +0x0fffffffffffffLL, -1074), MAKE_HEX_DOUBLE(+0x0.0000000000fffp-1022, +0x00000000000fffLL, -1074), MAKE_HEX_DOUBLE(+0x0.00000000000fep-1022, +0x000000000000feLL, -1074), MAKE_HEX_DOUBLE(+0x0.000000000000ep-1022, +0x0000000000000eLL, -1074), MAKE_HEX_DOUBLE(+0x0.000000000000cp-1022, +0x0000000000000cLL, -1074), MAKE_HEX_DOUBLE(+0x0.000000000000ap-1022, +0x0000000000000aLL, -1074),
    MAKE_HEX_DOUBLE(+0x0.0000000000008p-1022, +0x00000000000008LL, -1074), MAKE_HEX_DOUBLE(+0x0.0000000000007p-1022, +0x00000000000007LL, -1074), MAKE_HEX_DOUBLE(+0x0.0000000000006p-1022, +0x00000000000006LL, -1074), MAKE_HEX_DOUBLE(+0x0.0000000000005p-1022, +0x00000000000005LL, -1074), MAKE_HEX_DOUBLE(+0x0.0000000000004p-1022, +0x00000000000004LL, -1074),
    MAKE_HEX_DOUBLE(+0x0.0000000000003p-1022, +0x00000000000003LL, -1074), MAKE_HEX_DOUBLE(+0x0.0000000000002p-1022, +0x00000000000002LL, -1074), MAKE_HEX_DOUBLE(+0x0.0000000000001p-1022, +0x00000000000001LL, -1074), +0.0,

    MAKE_HEX_DOUBLE(-0x1.ffffffffffffep62, -0x1ffffffffffffeLL, 10), MAKE_HEX_DOUBLE(-0x1.ffffffffffffcp62, -0x1ffffffffffffcLL, 10), MAKE_HEX_DOUBLE(-0x1.fffffffffffffp62, -0x1fffffffffffffLL, 10), MAKE_HEX_DOUBLE(+0x1.ffffffffffffep62, +0x1ffffffffffffeLL, 10), MAKE_HEX_DOUBLE(+0x1.ffffffffffffcp62, +0x1ffffffffffffcLL, 10), MAKE_HEX_DOUBLE(+0x1.fffffffffffffp62, +0x1fffffffffffffLL, 10),
    MAKE_HEX_DOUBLE(-0x1.ffffffffffffep51, -0x1ffffffffffffeLL, -1), MAKE_HEX_DOUBLE(-0x1.ffffffffffffcp51, -0x1ffffffffffffcLL, -1), MAKE_HEX_DOUBLE(-0x1.fffffffffffffp51, -0x1fffffffffffffLL, -1), MAKE_HEX_DOUBLE(+0x1.ffffffffffffep51, +0x1ffffffffffffeLL, -1), MAKE_HEX_DOUBLE(+0x1.ffffffffffffcp51, +0x1ffffffffffffcLL, -1), MAKE_HEX_DOUBLE(+0x1.fffffffffffffp51, +0x1fffffffffffffLL, -1),
    MAKE_HEX_DOUBLE(-0x1.ffffffffffffep52, -0x1ffffffffffffeLL, 0), MAKE_HEX_DOUBLE(-0x1.ffffffffffffcp52, -0x1ffffffffffffcLL, 0), MAKE_HEX_DOUBLE(-0x1.fffffffffffffp52, -0x1fffffffffffffLL, 0), MAKE_HEX_DOUBLE(+0x1.ffffffffffffep52, +0x1ffffffffffffeLL, 0), MAKE_HEX_DOUBLE(+0x1.ffffffffffffcp52, +0x1ffffffffffffcLL, 0), MAKE_HEX_DOUBLE(+0x1.fffffffffffffp52, +0x1fffffffffffffLL, 0),
    MAKE_HEX_DOUBLE(-0x1.ffffffffffffep53, -0x1ffffffffffffeLL, 1), MAKE_HEX_DOUBLE(-0x1.ffffffffffffcp53, -0x1ffffffffffffcLL, 1), MAKE_HEX_DOUBLE(-0x1.fffffffffffffp53, -0x1fffffffffffffLL, 1), MAKE_HEX_DOUBLE(+0x1.ffffffffffffep53, +0x1ffffffffffffeLL, 1), MAKE_HEX_DOUBLE(+0x1.ffffffffffffcp53, +0x1ffffffffffffcLL, 1), MAKE_HEX_DOUBLE(+0x1.fffffffffffffp53, +0x1fffffffffffffLL, 1),
    MAKE_HEX_DOUBLE(-0x1.0000000000002p52, -0x10000000000002LL, 0), MAKE_HEX_DOUBLE(-0x1.0000000000001p52, -0x10000000000001LL, 0), MAKE_HEX_DOUBLE(-0x1.0p52, -0x1LL, 52), MAKE_HEX_DOUBLE(+0x1.0000000000002p52, +0x10000000000002LL, 0), MAKE_HEX_DOUBLE(+0x1.0000000000001p52, +0x10000000000001LL, 0), MAKE_HEX_DOUBLE(+0x1.0p52, +0x1LL, 52),
    MAKE_HEX_DOUBLE(-0x1.0000000000002p53, -0x10000000000002LL, 1), MAKE_HEX_DOUBLE(-0x1.0000000000001p53, -0x10000000000001LL, 1), MAKE_HEX_DOUBLE(-0x1.0p53, -0x1LL, 53), MAKE_HEX_DOUBLE(+0x1.0000000000002p53, +0x10000000000002LL, 1), MAKE_HEX_DOUBLE(+0x1.0000000000001p53, +0x10000000000001LL, 1), MAKE_HEX_DOUBLE(+0x1.0p53, +0x1LL, 53),
    MAKE_HEX_DOUBLE(-0x1.0000000000002p54, -0x10000000000002LL, 2), MAKE_HEX_DOUBLE(-0x1.0000000000001p54, -0x10000000000001LL, 2), MAKE_HEX_DOUBLE(-0x1.0p54, -0x1LL, 54), MAKE_HEX_DOUBLE(+0x1.0000000000002p54, +0x10000000000002LL, 2), MAKE_HEX_DOUBLE(+0x1.0000000000001p54, +0x10000000000001LL, 2), MAKE_HEX_DOUBLE(+0x1.0p54, +0x1LL, 54),
    MAKE_HEX_DOUBLE(-0x1.fffffffefffffp62, -0x1fffffffefffffLL, 10), MAKE_HEX_DOUBLE(-0x1.ffffffffp62, -0x1ffffffffLL, 30), MAKE_HEX_DOUBLE(-0x1.ffffffff00001p62, -0x1ffffffff00001LL, 10), MAKE_HEX_DOUBLE(0x1.fffffffefffffp62, 0x1fffffffefffffLL, 10), MAKE_HEX_DOUBLE(0x1.ffffffffp62, 0x1ffffffffLL, 30), MAKE_HEX_DOUBLE(0x1.ffffffff00001p62, 0x1ffffffff00001LL, 10),
};


void init_double( void *out, SaturationMode sat, RoundingMode round, Type destType, uint64_t start, int count, MTdata UNUSED d )
{
    double *o = (double*)out;
    int i;

    for( i = 0; i < count; i++ )
    {
        uint64_t z = i + start;
        o[i] = DoubleFromUInt32( (uint32_t) z ^ (uint32_t) (z >> 32));
    }

    if( 0 == start )
    {
        size_t tableSize = sizeof( specialValuesDouble );
        if( sizeof( cl_double) * count < tableSize )
            tableSize = sizeof( cl_double) * count;
        memcpy( (char*)(o + i) - tableSize, specialValuesDouble, tableSize );
    }

    if( 0 == sat )
    {
        clampd func = gClampDouble[ destType ][round];

        for( i = 0; i < count; i++ )
            o[i] = func( o[i] );
    }
}

cl_ulong random64( MTdata d )
{
    return (cl_ulong) genrand_int32(d) | ((cl_ulong) genrand_int32(d) << 32);
}

void init_ulong( void *out, SaturationMode UNUSED sat, RoundingMode UNUSED round, Type UNUSED destType, uint64_t start, int count, MTdata d )
{
    cl_ulong *o = (cl_ulong *)out;
    cl_ulong i, j, k;

    i = 0;
    if( start == 0 )
    {
        //Try various powers of two
        for( j = 0; j < (cl_ulong) count && j < 8 * sizeof(cl_ulong); j++ )
            o[j] = (cl_ulong) 1 << j;
        i = j;

        // try the complement of those
        for( j = 0; i < (cl_ulong) count && j < 8 * sizeof(cl_ulong); j++ )
            o[i++] = ~((cl_ulong) 1 << j);

        //Try various negative powers of two
        for( j = 0; i < (cl_ulong) count && j < 8 * sizeof(cl_ulong); j++ )
            o[i++] = (cl_ulong) 0xFFFFFFFFFFFFFFFEULL << j;

        //try various powers of two plus 1, shifted by various amounts
        for( j = 0; i < (cl_ulong)count && j < 8 * sizeof(cl_ulong); j++ )
            for( k = 0; i < (cl_ulong)count && k < 8 * sizeof(cl_ulong) - j; k++ )
                o[i++] = (((cl_ulong) 1 << j) + 1) << k;

        //try various powers of two minus 1
        for( j = 0; i < (cl_ulong)count && j < 8 * sizeof(cl_ulong); j++ )
            for( k = 0; i < (cl_ulong)count && k < 8 * sizeof(cl_ulong) - j; k++ )
                o[i++] = (((cl_ulong) 1 << j) - 1) << k;

        // Other patterns
        cl_ulong pattern[] = { 0x3333333333333333ULL, 0x5555555555555555ULL, 0x9999999999999999ULL, 0x6666666666666666ULL, 0xccccccccccccccccULL, 0xaaaaaaaaaaaaaaaaULL };
        cl_ulong mask[] = { 0xffffffffffffffffULL, 0xff00ff00ff00ff00ULL, 0xffff0000ffff0000ULL, 0xffffffff00000000ULL };
        for( j = 0; i < (cl_ulong) count && j < sizeof(pattern) / sizeof( pattern[0]); j++ )
            for( k = 0; i + 2 <= (cl_ulong) count && k < sizeof(mask) / sizeof( mask[0]); k++ )
            {
                o[i++] = pattern[j] & mask[k];
                o[i++] = pattern[j] & ~mask[k];
            }
    }

    for( ; i < (cl_ulong) count; i++ )
        o[i] = random64(d);
}

void init_long( void *out, SaturationMode sat, RoundingMode round, Type destType, uint64_t start, int count, MTdata d )
{
    init_ulong( out, sat, round, destType, start, count, d );
}

// ======

void uchar2uchar_many( void *out, void *in, size_t n);
void uchar2uchar_sat_many( void *out, void *in, size_t n);
void char2uchar_many( void *out, void *in, size_t n);
void char2uchar_sat_many( void *out, void *in, size_t n);
void ushort2uchar_many( void *out, void *in, size_t n);
void ushort2uchar_sat_many( void *out, void *in, size_t n);
void short2uchar_many( void *out, void *in, size_t n);
void short2uchar_sat_many( void *out, void *in, size_t n);
void uint2uchar_many( void *out, void *in, size_t n);
void uint2uchar_sat_many( void *out, void *in, size_t n);
void int2uchar_many( void *out, void *in, size_t n);
void int2uchar_sat_many( void *out, void *in, size_t n);
void float2uchar_many( void *out, void *in, size_t n);
void float2uchar_sat_many( void *out, void *in, size_t n);
void double2uchar_many( void *out, void *in, size_t n);
void double2uchar_sat_many( void *out, void *in, size_t n);
void ulong2uchar_many( void *out, void *in, size_t n);
void ulong2uchar_sat_many( void *out, void *in, size_t n);
void long2uchar_many( void *out, void *in, size_t n);
void long2uchar_sat_many( void *out, void *in, size_t n);
void uchar2char_many( void *out, void *in, size_t n);
void uchar2char_sat_many( void *out, void *in, size_t n);
void char2char_many( void *out, void *in, size_t n);
void char2char_sat_many( void *out, void *in, size_t n);
void ushort2char_many( void *out, void *in, size_t n);
void ushort2char_sat_many( void *out, void *in, size_t n);
void short2char_many( void *out, void *in, size_t n);
void short2char_sat_many( void *out, void *in, size_t n);
void uint2char_many( void *out, void *in, size_t n);
void uint2char_sat_many( void *out, void *in, size_t n);
void int2char_many( void *out, void *in, size_t n);
void int2char_sat_many( void *out, void *in, size_t n);
void float2char_many( void *out, void *in, size_t n);
void float2char_sat_many( void *out, void *in, size_t n);
void double2char_many( void *out, void *in, size_t n);
void double2char_sat_many( void *out, void *in, size_t n);
void ulong2char_many( void *out, void *in, size_t n);
void ulong2char_sat_many( void *out, void *in, size_t n);
void long2char_many( void *out, void *in, size_t n);
void long2char_sat_many( void *out, void *in, size_t n);
void uchar2ushort_many( void *out, void *in, size_t n);
void uchar2ushort_sat_many( void *out, void *in, size_t n);
void char2ushort_many( void *out, void *in, size_t n);
void char2ushort_sat_many( void *out, void *in, size_t n);
void ushort2ushort_many( void *out, void *in, size_t n);
void ushort2ushort_sat_many( void *out, void *in, size_t n);
void short2ushort_many( void *out, void *in, size_t n);
void short2ushort_sat_many( void *out, void *in, size_t n);
void uint2ushort_many( void *out, void *in, size_t n);
void uint2ushort_sat_many( void *out, void *in, size_t n);
void int2ushort_many( void *out, void *in, size_t n);
void int2ushort_sat_many( void *out, void *in, size_t n);
void float2ushort_many( void *out, void *in, size_t n);
void float2ushort_sat_many( void *out, void *in, size_t n);
void double2ushort_many( void *out, void *in, size_t n);
void double2ushort_sat_many( void *out, void *in, size_t n);
void ulong2ushort_many( void *out, void *in, size_t n);
void ulong2ushort_sat_many( void *out, void *in, size_t n);
void long2ushort_many( void *out, void *in, size_t n);
void long2ushort_sat_many( void *out, void *in, size_t n);
void uchar2short_many( void *out, void *in, size_t n);
void uchar2short_sat_many( void *out, void *in, size_t n);
void char2short_many( void *out, void *in, size_t n);
void char2short_sat_many( void *out, void *in, size_t n);
void ushort2short_many( void *out, void *in, size_t n);
void ushort2short_sat_many( void *out, void *in, size_t n);
void short2short_many( void *out, void *in, size_t n);
void short2short_sat_many( void *out, void *in, size_t n);
void uint2short_many( void *out, void *in, size_t n);
void uint2short_sat_many( void *out, void *in, size_t n);
void int2short_many( void *out, void *in, size_t n);
void int2short_sat_many( void *out, void *in, size_t n);
void float2short_many( void *out, void *in, size_t n);
void float2short_sat_many( void *out, void *in, size_t n);
void double2short_many( void *out, void *in, size_t n);
void double2short_sat_many( void *out, void *in, size_t n);
void ulong2short_many( void *out, void *in, size_t n);
void ulong2short_sat_many( void *out, void *in, size_t n);
void long2short_many( void *out, void *in, size_t n);
void long2short_sat_many( void *out, void *in, size_t n);
void uchar2uint_many( void *out, void *in, size_t n);
void uchar2uint_sat_many( void *out, void *in, size_t n);
void char2uint_many( void *out, void *in, size_t n);
void char2uint_sat_many( void *out, void *in, size_t n);
void ushort2uint_many( void *out, void *in, size_t n);
void ushort2uint_sat_many( void *out, void *in, size_t n);
void short2uint_many( void *out, void *in, size_t n);
void short2uint_sat_many( void *out, void *in, size_t n);
void uint2uint_many( void *out, void *in, size_t n);
void uint2uint_sat_many( void *out, void *in, size_t n);
void int2uint_many( void *out, void *in, size_t n);
void int2uint_sat_many( void *out, void *in, size_t n);
void float2uint_many( void *out, void *in, size_t n);
void float2uint_sat_many( void *out, void *in, size_t n);
void double2uint_many( void *out, void *in, size_t n);
void double2uint_sat_many( void *out, void *in, size_t n);
void ulong2uint_many( void *out, void *in, size_t n);
void ulong2uint_sat_many( void *out, void *in, size_t n);
void long2uint_many( void *out, void *in, size_t n);
void long2uint_sat_many( void *out, void *in, size_t n);
void uchar2int_many( void *out, void *in, size_t n);
void uchar2int_sat_many( void *out, void *in, size_t n);
void char2int_many( void *out, void *in, size_t n);
void char2int_sat_many( void *out, void *in, size_t n);
void ushort2int_many( void *out, void *in, size_t n);
void ushort2int_sat_many( void *out, void *in, size_t n);
void short2int_many( void *out, void *in, size_t n);
void short2int_sat_many( void *out, void *in, size_t n);
void uint2int_many( void *out, void *in, size_t n);
void uint2int_sat_many( void *out, void *in, size_t n);
void int2int_many( void *out, void *in, size_t n);
void int2int_sat_many( void *out, void *in, size_t n);
void float2int_many( void *out, void *in, size_t n);
void float2int_sat_many( void *out, void *in, size_t n);
void double2int_many( void *out, void *in, size_t n);
void double2int_sat_many( void *out, void *in, size_t n);
void ulong2int_many( void *out, void *in, size_t n);
void ulong2int_sat_many( void *out, void *in, size_t n);
void long2int_many( void *out, void *in, size_t n);
void long2int_sat_many( void *out, void *in, size_t n);
void uchar2float_many( void *out, void *in, size_t n);
void uchar2float_sat_many( void *out, void *in, size_t n);
void char2float_many( void *out, void *in, size_t n);
void char2float_sat_many( void *out, void *in, size_t n);
void ushort2float_many( void *out, void *in, size_t n);
void ushort2float_sat_many( void *out, void *in, size_t n);
void short2float_many( void *out, void *in, size_t n);
void short2float_sat_many( void *out, void *in, size_t n);
void uint2float_many( void *out, void *in, size_t n);
void uint2float_sat_many( void *out, void *in, size_t n);
void int2float_many( void *out, void *in, size_t n);
void int2float_sat_many( void *out, void *in, size_t n);
void float2float_many( void *out, void *in, size_t n);
void float2float_sat_many( void *out, void *in, size_t n);
void double2float_many( void *out, void *in, size_t n);
void double2float_sat_many( void *out, void *in, size_t n);
void ulong2float_many( void *out, void *in, size_t n);
void ulong2float_sat_many( void *out, void *in, size_t n);
void long2float_many( void *out, void *in, size_t n);
void long2float_sat_many( void *out, void *in, size_t n);
void uchar2double_many( void *out, void *in, size_t n);
void uchar2double_sat_many( void *out, void *in, size_t n);
void char2double_many( void *out, void *in, size_t n);
void char2double_sat_many( void *out, void *in, size_t n);
void ushort2double_many( void *out, void *in, size_t n);
void ushort2double_sat_many( void *out, void *in, size_t n);
void short2double_many( void *out, void *in, size_t n);
void short2double_sat_many( void *out, void *in, size_t n);
void uint2double_many( void *out, void *in, size_t n);
void uint2double_sat_many( void *out, void *in, size_t n);
void int2double_many( void *out, void *in, size_t n);
void int2double_sat_many( void *out, void *in, size_t n);
void float2double_many( void *out, void *in, size_t n);
void float2double_sat_many( void *out, void *in, size_t n);
void double2double_many( void *out, void *in, size_t n);
void double2double_sat_many( void *out, void *in, size_t n);
void ulong2double_many( void *out, void *in, size_t n);
void ulong2double_sat_many( void *out, void *in, size_t n);
void long2double_many( void *out, void *in, size_t n);
void long2double_sat_many( void *out, void *in, size_t n);
void uchar2ulong_many( void *out, void *in, size_t n);
void uchar2ulong_sat_many( void *out, void *in, size_t n);
void char2ulong_many( void *out, void *in, size_t n);
void char2ulong_sat_many( void *out, void *in, size_t n);
void ushort2ulong_many( void *out, void *in, size_t n);
void ushort2ulong_sat_many( void *out, void *in, size_t n);
void short2ulong_many( void *out, void *in, size_t n);
void short2ulong_sat_many( void *out, void *in, size_t n);
void uint2ulong_many( void *out, void *in, size_t n);
void uint2ulong_sat_many( void *out, void *in, size_t n);
void int2ulong_many( void *out, void *in, size_t n);
void int2ulong_sat_many( void *out, void *in, size_t n);
void float2ulong_many( void *out, void *in, size_t n);
void float2ulong_sat_many( void *out, void *in, size_t n);
void double2ulong_many( void *out, void *in, size_t n);
void double2ulong_sat_many( void *out, void *in, size_t n);
void ulong2ulong_many( void *out, void *in, size_t n);
void ulong2ulong_sat_many( void *out, void *in, size_t n);
void long2ulong_many( void *out, void *in, size_t n);
void long2ulong_sat_many( void *out, void *in, size_t n);
void uchar2long_many( void *out, void *in, size_t n);
void uchar2long_sat_many( void *out, void *in, size_t n);
void char2long_many( void *out, void *in, size_t n);
void char2long_sat_many( void *out, void *in, size_t n);
void ushort2long_many( void *out, void *in, size_t n);
void ushort2long_sat_many( void *out, void *in, size_t n);
void short2long_many( void *out, void *in, size_t n);
void short2long_sat_many( void *out, void *in, size_t n);
void uint2long_many( void *out, void *in, size_t n);
void uint2long_sat_many( void *out, void *in, size_t n);
void int2long_many( void *out, void *in, size_t n);
void int2long_sat_many( void *out, void *in, size_t n);
void float2long_many( void *out, void *in, size_t n);
void float2long_sat_many( void *out, void *in, size_t n);
void double2long_many( void *out, void *in, size_t n);
void double2long_sat_many( void *out, void *in, size_t n);
void ulong2long_many( void *out, void *in, size_t n);
void ulong2long_sat_many( void *out, void *in, size_t n);
void long2long_many( void *out, void *in, size_t n);
void long2long_sat_many( void *out, void *in, size_t n);

void uchar2uchar_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_uchar )); }
void uchar2uchar_sat_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_uchar )); }
void char2uchar_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2uchar( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_char)); }}
void char2uchar_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2uchar_sat( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_char)); }}
void ushort2uchar_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2uchar( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_ushort)); }}
void ushort2uchar_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2uchar_sat( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_ushort)); }}
void short2uchar_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2uchar( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_short)); }}
void short2uchar_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2uchar_sat( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_short)); }}
void uint2uchar_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2uchar( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_uint)); }}
void uint2uchar_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2uchar_sat( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_uint)); }}
void int2uchar_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2uchar( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_int)); }}
void int2uchar_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2uchar_sat( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_int)); }}
void float2uchar_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2uchar( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_float)); }}
void float2uchar_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2uchar_sat( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_float)); }}
void double2uchar_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2uchar( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_double)); }}
void double2uchar_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2uchar_sat( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_double)); }}
void ulong2uchar_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2uchar( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_ulong)); }}
void ulong2uchar_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2uchar_sat( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_ulong)); }}
void long2uchar_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2uchar( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_long)); }}
void long2uchar_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2uchar_sat( (char*) out + i * sizeof(cl_uchar), (char*) in + i * sizeof(cl_long)); }}
void uchar2char_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2char( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_uchar)); }}
void uchar2char_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2char_sat( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_uchar)); }}
void char2char_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_char )); }
void char2char_sat_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_char )); }
void ushort2char_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2char( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_ushort)); }}
void ushort2char_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2char_sat( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_ushort)); }}
void short2char_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2char( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_short)); }}
void short2char_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2char_sat( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_short)); }}
void uint2char_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2char( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_uint)); }}
void uint2char_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2char_sat( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_uint)); }}
void int2char_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2char( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_int)); }}
void int2char_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2char_sat( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_int)); }}
void float2char_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2char( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_float)); }}
void float2char_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2char_sat( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_float)); }}
void double2char_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2char( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_double)); }}
void double2char_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2char_sat( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_double)); }}
void ulong2char_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2char( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_ulong)); }}
void ulong2char_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2char_sat( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_ulong)); }}
void long2char_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2char( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_long)); }}
void long2char_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2char_sat( (char*) out + i * sizeof(cl_char), (char*) in + i * sizeof(cl_long)); }}
void uchar2ushort_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2ushort( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_uchar)); }}
void uchar2ushort_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2ushort_sat( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_uchar)); }}
void char2ushort_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2ushort( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_char)); }}
void char2ushort_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2ushort_sat( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_char)); }}
void ushort2ushort_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_ushort )); }
void ushort2ushort_sat_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_ushort )); }
void short2ushort_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2ushort( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_short)); }}
void short2ushort_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2ushort_sat( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_short)); }}
void uint2ushort_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2ushort( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_uint)); }}
void uint2ushort_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2ushort_sat( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_uint)); }}
void int2ushort_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2ushort( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_int)); }}
void int2ushort_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2ushort_sat( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_int)); }}
void float2ushort_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2ushort( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_float)); }}
void float2ushort_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2ushort_sat( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_float)); }}
void double2ushort_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2ushort( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_double)); }}
void double2ushort_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2ushort_sat( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_double)); }}
void ulong2ushort_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2ushort( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_ulong)); }}
void ulong2ushort_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2ushort_sat( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_ulong)); }}
void long2ushort_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2ushort( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_long)); }}
void long2ushort_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2ushort_sat( (char*) out + i * sizeof(cl_ushort), (char*) in + i * sizeof(cl_long)); }}
void uchar2short_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2short( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_uchar)); }}
void uchar2short_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2short_sat( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_uchar)); }}
void char2short_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2short( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_char)); }}
void char2short_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2short_sat( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_char)); }}
void ushort2short_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2short( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_ushort)); }}
void ushort2short_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2short_sat( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_ushort)); }}
void short2short_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_short )); }
void short2short_sat_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_short )); }
void uint2short_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2short( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_uint)); }}
void uint2short_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2short_sat( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_uint)); }}
void int2short_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2short( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_int)); }}
void int2short_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2short_sat( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_int)); }}
void float2short_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2short( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_float)); }}
void float2short_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2short_sat( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_float)); }}
void double2short_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2short( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_double)); }}
void double2short_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2short_sat( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_double)); }}
void ulong2short_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2short( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_ulong)); }}
void ulong2short_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2short_sat( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_ulong)); }}
void long2short_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2short( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_long)); }}
void long2short_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2short_sat( (char*) out + i * sizeof(cl_short), (char*) in + i * sizeof(cl_long)); }}
void uchar2uint_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2uint( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_uchar)); }}
void uchar2uint_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2uint_sat( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_uchar)); }}
void char2uint_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2uint( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_char)); }}
void char2uint_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2uint_sat( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_char)); }}
void ushort2uint_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2uint( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_ushort)); }}
void ushort2uint_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2uint_sat( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_ushort)); }}
void short2uint_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2uint( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_short)); }}
void short2uint_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2uint_sat( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_short)); }}
void uint2uint_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_uint )); }
void uint2uint_sat_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_uint )); }
void int2uint_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2uint( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_int)); }}
void int2uint_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2uint_sat( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_int)); }}
void float2uint_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2uint( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_float)); }}
void float2uint_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2uint_sat( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_float)); }}
void double2uint_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2uint( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_double)); }}
void double2uint_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2uint_sat( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_double)); }}
void ulong2uint_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2uint( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_ulong)); }}
void ulong2uint_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2uint_sat( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_ulong)); }}
void long2uint_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2uint( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_long)); }}
void long2uint_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2uint_sat( (char*) out + i * sizeof(cl_uint), (char*) in + i * sizeof(cl_long)); }}
void uchar2int_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2int( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_uchar)); }}
void uchar2int_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2int_sat( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_uchar)); }}
void char2int_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2int( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_char)); }}
void char2int_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2int_sat( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_char)); }}
void ushort2int_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2int( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_ushort)); }}
void ushort2int_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2int_sat( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_ushort)); }}
void short2int_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2int( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_short)); }}
void short2int_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2int_sat( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_short)); }}
void uint2int_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2int( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_uint)); }}
void uint2int_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2int_sat( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_uint)); }}
void int2int_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_int )); }
void int2int_sat_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_int )); }
void float2int_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2int( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_float)); }}
void float2int_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2int_sat( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_float)); }}
void double2int_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2int( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_double)); }}
void double2int_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2int_sat( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_double)); }}
void ulong2int_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2int( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_ulong)); }}
void ulong2int_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2int_sat( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_ulong)); }}
void long2int_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2int( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_long)); }}
void long2int_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2int_sat( (char*) out + i * sizeof(cl_int), (char*) in + i * sizeof(cl_long)); }}
void uchar2float_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2float( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_uchar)); }}
void uchar2float_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2float_sat( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_uchar)); }}
void char2float_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2float( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_char)); }}
void char2float_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2float_sat( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_char)); }}
void ushort2float_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2float( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_ushort)); }}
void ushort2float_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2float_sat( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_ushort)); }}
void short2float_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2float( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_short)); }}
void short2float_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2float_sat( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_short)); }}
void uint2float_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2float( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_uint)); }}
void uint2float_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2float_sat( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_uint)); }}
void int2float_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2float( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_int)); }}
void int2float_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2float_sat( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_int)); }}
void float2float_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_float )); }
void float2float_sat_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_float )); }
void double2float_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2float( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_double)); }}
void double2float_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2float_sat( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_double)); }}
void ulong2float_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2float( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_ulong)); }}
void ulong2float_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2float_sat( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_ulong)); }}
void long2float_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2float( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_long)); }}
void long2float_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2float_sat( (char*) out + i * sizeof(cl_float), (char*) in + i * sizeof(cl_long)); }}
void uchar2double_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2double( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_uchar)); }}
void uchar2double_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2double_sat( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_uchar)); }}
void char2double_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2double( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_char)); }}
void char2double_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2double_sat( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_char)); }}
void ushort2double_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2double( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_ushort)); }}
void ushort2double_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2double_sat( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_ushort)); }}
void short2double_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2double( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_short)); }}
void short2double_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2double_sat( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_short)); }}
void uint2double_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2double( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_uint)); }}
void uint2double_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2double_sat( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_uint)); }}
void int2double_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2double( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_int)); }}
void int2double_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2double_sat( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_int)); }}
void float2double_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2double( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_float)); }}
void float2double_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2double_sat( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_float)); }}
void double2double_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_double )); }
void double2double_sat_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_double )); }
void ulong2double_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2double( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_ulong)); }}
void ulong2double_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2double_sat( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_ulong)); }}
void long2double_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2double( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_long)); }}
void long2double_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2double_sat( (char*) out + i * sizeof(cl_double), (char*) in + i * sizeof(cl_long)); }}
void uchar2ulong_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2ulong( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_uchar)); }}
void uchar2ulong_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2ulong_sat( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_uchar)); }}
void char2ulong_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2ulong( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_char)); }}
void char2ulong_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2ulong_sat( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_char)); }}
void ushort2ulong_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2ulong( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_ushort)); }}
void ushort2ulong_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2ulong_sat( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_ushort)); }}
void short2ulong_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2ulong( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_short)); }}
void short2ulong_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2ulong_sat( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_short)); }}
void uint2ulong_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2ulong( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_uint)); }}
void uint2ulong_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2ulong_sat( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_uint)); }}
void int2ulong_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2ulong( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_int)); }}
void int2ulong_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2ulong_sat( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_int)); }}
void float2ulong_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2ulong( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_float)); }}
void float2ulong_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2ulong_sat( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_float)); }}
void double2ulong_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2ulong( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_double)); }}
void double2ulong_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2ulong_sat( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_double)); }}
void ulong2ulong_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_ulong )); }
void ulong2ulong_sat_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_ulong )); }
void long2ulong_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2ulong( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_long)); }}
void long2ulong_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ long2ulong_sat( (char*) out + i * sizeof(cl_ulong), (char*) in + i * sizeof(cl_long)); }}
void uchar2long_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2long( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_uchar)); }}
void uchar2long_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uchar2long_sat( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_uchar)); }}
void char2long_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2long( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_char)); }}
void char2long_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ char2long_sat( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_char)); }}
void ushort2long_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2long( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_ushort)); }}
void ushort2long_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ushort2long_sat( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_ushort)); }}
void short2long_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2long( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_short)); }}
void short2long_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ short2long_sat( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_short)); }}
void uint2long_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2long( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_uint)); }}
void uint2long_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ uint2long_sat( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_uint)); }}
void int2long_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2long( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_int)); }}
void int2long_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ int2long_sat( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_int)); }}
void float2long_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2long( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_float)); }}
void float2long_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ float2long_sat( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_float)); }}
void double2long_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2long( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_double)); }}
void double2long_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ double2long_sat( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_double)); }}
void ulong2long_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2long( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_ulong)); }}
void ulong2long_sat_many( void *out, void *in, size_t n){size_t i; for( i = 0; i < n; i++){ ulong2long_sat( (char*) out + i * sizeof(cl_long), (char*) in + i * sizeof(cl_ulong)); }}
void long2long_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_long )); }
void long2long_sat_many( void *out, void *in, size_t n){ memcpy( out, in, n * sizeof( cl_long )); }

Convert gSaturatedConversions[kTypeCount][kTypeCount] = {
    {    uchar2uchar_sat_many,    char2uchar_sat_many,    ushort2uchar_sat_many,    short2uchar_sat_many,    uint2uchar_sat_many,    int2uchar_sat_many,    float2uchar_sat_many,    double2uchar_sat_many,    ulong2uchar_sat_many,    long2uchar_sat_many,     },
    {    uchar2char_sat_many,    char2char_sat_many,    ushort2char_sat_many,    short2char_sat_many,    uint2char_sat_many,    int2char_sat_many,    float2char_sat_many,    double2char_sat_many,    ulong2char_sat_many, long2char_sat_many,     },
    {    uchar2ushort_sat_many,    char2ushort_sat_many,    ushort2ushort_sat_many,    short2ushort_sat_many,    uint2ushort_sat_many,    int2ushort_sat_many,    float2ushort_sat_many,    double2ushort_sat_many,    ulong2ushort_sat_many,    long2ushort_sat_many,     },
    {    uchar2short_sat_many,    char2short_sat_many,    ushort2short_sat_many,    short2short_sat_many,    uint2short_sat_many,    int2short_sat_many,    float2short_sat_many,    double2short_sat_many,    ulong2short_sat_many,    long2short_sat_many,     },
    {    uchar2uint_sat_many,    char2uint_sat_many,    ushort2uint_sat_many,    short2uint_sat_many,    uint2uint_sat_many,    int2uint_sat_many,    float2uint_sat_many,    double2uint_sat_many,    ulong2uint_sat_many, long2uint_sat_many,     },
    {    uchar2int_sat_many,    char2int_sat_many,    ushort2int_sat_many,    short2int_sat_many,    uint2int_sat_many,    int2int_sat_many,    float2int_sat_many,    double2int_sat_many,    ulong2int_sat_many,long2int_sat_many,     },
    {    uchar2float_sat_many,    char2float_sat_many,    ushort2float_sat_many,    short2float_sat_many,    uint2float_sat_many,    int2float_sat_many,    float2float_sat_many,    double2float_sat_many,    ulong2float_sat_many,    long2float_sat_many,     },
    {    uchar2double_sat_many,    char2double_sat_many,    ushort2double_sat_many,    short2double_sat_many,    uint2double_sat_many,    int2double_sat_many,    float2double_sat_many,    double2double_sat_many,    ulong2double_sat_many,    long2double_sat_many,     },
    {    uchar2ulong_sat_many,    char2ulong_sat_many,    ushort2ulong_sat_many,    short2ulong_sat_many,    uint2ulong_sat_many,    int2ulong_sat_many,    float2ulong_sat_many,    double2ulong_sat_many,    ulong2ulong_sat_many,    long2ulong_sat_many,     },
    {    uchar2long_sat_many,    char2long_sat_many,    ushort2long_sat_many,    short2long_sat_many,    uint2long_sat_many,    int2long_sat_many,    float2long_sat_many,    double2long_sat_many,    ulong2long_sat_many, long2long_sat_many,     },
};

Convert gConversions[kTypeCount][kTypeCount] = {
    {    uchar2uchar_many,    char2uchar_many,    ushort2uchar_many,    short2uchar_many,    uint2uchar_many,    int2uchar_many,    float2uchar_many,    double2uchar_many,    ulong2uchar_many,    long2uchar_many,     },
    {    uchar2char_many,    char2char_many,    ushort2char_many,    short2char_many,    uint2char_many,    int2char_many,    float2char_many,    double2char_many,    ulong2char_many,    long2char_many,     },
    {    uchar2ushort_many,    char2ushort_many,    ushort2ushort_many,    short2ushort_many,    uint2ushort_many,    int2ushort_many,    float2ushort_many,    double2ushort_many,    ulong2ushort_many,    long2ushort_many,     },
    {    uchar2short_many,    char2short_many,    ushort2short_many,    short2short_many,    uint2short_many,    int2short_many,    float2short_many,    double2short_many,    ulong2short_many,    long2short_many,     },
    {    uchar2uint_many,    char2uint_many,    ushort2uint_many,    short2uint_many,    uint2uint_many,    int2uint_many,    float2uint_many,    double2uint_many,    ulong2uint_many,    long2uint_many,     },
    {    uchar2int_many,    char2int_many,    ushort2int_many,    short2int_many,    uint2int_many,    int2int_many,    float2int_many,    double2int_many,    ulong2int_many,    long2int_many,     },
    {    uchar2float_many,    char2float_many,    ushort2float_many,    short2float_many,    uint2float_many,    int2float_many,    float2float_many,    double2float_many,    ulong2float_many,    long2float_many,     },
    {    uchar2double_many,    char2double_many,    ushort2double_many,    short2double_many,    uint2double_many,    int2double_many,    float2double_many,    double2double_many,    ulong2double_many,    long2double_many,     },
    {    uchar2ulong_many,    char2ulong_many,    ushort2ulong_many,    short2ulong_many,    uint2ulong_many,    int2ulong_many,    float2ulong_many,    double2ulong_many,    ulong2ulong_many,    long2ulong_many,     },
    {    uchar2long_many,    char2long_many,    ushort2long_many,    short2long_many,    uint2long_many,    int2long_many,    float2long_many,    double2long_many,    ulong2long_many,    long2long_many,     },
};