// AUTO-GENERATED by generate_wrappers.go - DO NOT EDIT
// This file contains the function pointer definitions and initialization
// All function pointers are in a single compilation unit to avoid duplication

#include "mlx/c/mlx.h"
#include "mlx_dynamic.h"
#include <stdio.h>
#include <dlfcn.h>

// Function pointer definitions
size_t (*mlx_dtype_size_ptr)(mlx_dtype dtype) = NULL;
int (*mlx_array_tostring_ptr)(mlx_string* str, const mlx_array arr) = NULL;
mlx_array (*mlx_array_new_ptr)(void) = NULL;
int (*mlx_array_free_ptr)(mlx_array arr) = NULL;
mlx_array (*mlx_array_new_bool_ptr)(bool val) = NULL;
mlx_array (*mlx_array_new_int_ptr)(int val) = NULL;
mlx_array (*mlx_array_new_float32_ptr)(float val) = NULL;
mlx_array (*mlx_array_new_float_ptr)(float val) = NULL;
mlx_array (*mlx_array_new_float64_ptr)(double val) = NULL;
mlx_array (*mlx_array_new_double_ptr)(double val) = NULL;
mlx_array (*mlx_array_new_complex_ptr)(float real_val, float imag_val) = NULL;
mlx_array (*mlx_array_new_data_ptr)(const void* data, const int* shape, int dim, mlx_dtype dtype) = NULL;
int (*mlx_array_set_ptr)(mlx_array* arr, const mlx_array src) = NULL;
int (*mlx_array_set_bool_ptr)(mlx_array* arr, bool val) = NULL;
int (*mlx_array_set_int_ptr)(mlx_array* arr, int val) = NULL;
int (*mlx_array_set_float32_ptr)(mlx_array* arr, float val) = NULL;
int (*mlx_array_set_float_ptr)(mlx_array* arr, float val) = NULL;
int (*mlx_array_set_float64_ptr)(mlx_array* arr, double val) = NULL;
int (*mlx_array_set_double_ptr)(mlx_array* arr, double val) = NULL;
int (*mlx_array_set_complex_ptr)(mlx_array* arr, float real_val, float imag_val) = NULL;
int (*mlx_array_set_data_ptr)(mlx_array* arr, const void* data, const int* shape, int dim, mlx_dtype dtype) = NULL;
size_t (*mlx_array_itemsize_ptr)(const mlx_array arr) = NULL;
size_t (*mlx_array_size_ptr)(const mlx_array arr) = NULL;
size_t (*mlx_array_nbytes_ptr)(const mlx_array arr) = NULL;
size_t (*mlx_array_ndim_ptr)(const mlx_array arr) = NULL;
const int* (*mlx_array_shape_ptr)(const mlx_array arr) = NULL;
const size_t* (*mlx_array_strides_ptr)(const mlx_array arr) = NULL;
int (*mlx_array_dim_ptr)(const mlx_array arr, int dim) = NULL;
mlx_dtype (*mlx_array_dtype_ptr)(const mlx_array arr) = NULL;
int (*mlx_array_eval_ptr)(mlx_array arr) = NULL;
int (*mlx_array_item_bool_ptr)(bool* res, const mlx_array arr) = NULL;
int (*mlx_array_item_uint8_ptr)(uint8_t* res, const mlx_array arr) = NULL;
int (*mlx_array_item_uint16_ptr)(uint16_t* res, const mlx_array arr) = NULL;
int (*mlx_array_item_uint32_ptr)(uint32_t* res, const mlx_array arr) = NULL;
int (*mlx_array_item_uint64_ptr)(uint64_t* res, const mlx_array arr) = NULL;
int (*mlx_array_item_int8_ptr)(int8_t* res, const mlx_array arr) = NULL;
int (*mlx_array_item_int16_ptr)(int16_t* res, const mlx_array arr) = NULL;
int (*mlx_array_item_int32_ptr)(int32_t* res, const mlx_array arr) = NULL;
int (*mlx_array_item_int64_ptr)(int64_t* res, const mlx_array arr) = NULL;
int (*mlx_array_item_float32_ptr)(float* res, const mlx_array arr) = NULL;
int (*mlx_array_item_float64_ptr)(double* res, const mlx_array arr) = NULL;
int (*mlx_array_item_complex64_ptr)(float _Complex* res, const mlx_array arr) = NULL;
#if defined(__aarch64__) || defined(_M_ARM64)
int (*mlx_array_item_float16_ptr)(float16_t* res, const mlx_array arr) = NULL;
#endif
#if defined(__aarch64__) || defined(_M_ARM64)
int (*mlx_array_item_bfloat16_ptr)(bfloat16_t* res, const mlx_array arr) = NULL;
#endif
const bool* (*mlx_array_data_bool_ptr)(const mlx_array arr) = NULL;
const uint8_t* (*mlx_array_data_uint8_ptr)(const mlx_array arr) = NULL;
const uint16_t* (*mlx_array_data_uint16_ptr)(const mlx_array arr) = NULL;
const uint32_t* (*mlx_array_data_uint32_ptr)(const mlx_array arr) = NULL;
const uint64_t* (*mlx_array_data_uint64_ptr)(const mlx_array arr) = NULL;
const int8_t* (*mlx_array_data_int8_ptr)(const mlx_array arr) = NULL;
const int16_t* (*mlx_array_data_int16_ptr)(const mlx_array arr) = NULL;
const int32_t* (*mlx_array_data_int32_ptr)(const mlx_array arr) = NULL;
const int64_t* (*mlx_array_data_int64_ptr)(const mlx_array arr) = NULL;
const float* (*mlx_array_data_float32_ptr)(const mlx_array arr) = NULL;
const double* (*mlx_array_data_float64_ptr)(const mlx_array arr) = NULL;
const float _Complex* (*mlx_array_data_complex64_ptr)(const mlx_array arr) = NULL;
#if defined(__aarch64__) || defined(_M_ARM64)
const float16_t* (*mlx_array_data_float16_ptr)(const mlx_array arr) = NULL;
#endif
#if defined(__aarch64__) || defined(_M_ARM64)
const bfloat16_t* (*mlx_array_data_bfloat16_ptr)(const mlx_array arr) = NULL;
#endif
int (*_mlx_array_is_available_ptr)(bool* res, const mlx_array arr) = NULL;
int (*_mlx_array_wait_ptr)(const mlx_array arr) = NULL;
int (*_mlx_array_is_contiguous_ptr)(bool* res, const mlx_array arr) = NULL;
int (*_mlx_array_is_row_contiguous_ptr)(bool* res, const mlx_array arr) = NULL;
int (*_mlx_array_is_col_contiguous_ptr)(bool* res, const mlx_array arr) = NULL;
mlx_closure (*mlx_closure_new_ptr)(void) = NULL;
int (*mlx_closure_free_ptr)(mlx_closure cls) = NULL;
mlx_closure (*mlx_closure_new_func_ptr)(int (*fun)(mlx_vector_array*, const mlx_vector_array)) = NULL;
mlx_closure (*mlx_closure_new_func_payload_ptr)(int (*fun)(mlx_vector_array*, const mlx_vector_array, void*), void* payload, void (*dtor)(void*)) = NULL;
int (*mlx_closure_set_ptr)(mlx_closure* cls, const mlx_closure src) = NULL;
int (*mlx_closure_apply_ptr)(mlx_vector_array* res, mlx_closure cls, const mlx_vector_array input) = NULL;
mlx_closure (*mlx_closure_new_unary_ptr)(int (*fun)(mlx_array*, const mlx_array)) = NULL;
mlx_closure_kwargs (*mlx_closure_kwargs_new_ptr)(void) = NULL;
int (*mlx_closure_kwargs_free_ptr)(mlx_closure_kwargs cls) = NULL;
mlx_closure_kwargs (*mlx_closure_kwargs_new_func_ptr)(int (*fun)( mlx_vector_array*, const mlx_vector_array, const mlx_map_string_to_array)) = NULL;
mlx_closure_kwargs (*mlx_closure_kwargs_new_func_payload_ptr)(int (*fun)( mlx_vector_array*, const mlx_vector_array, const mlx_map_string_to_array, void*), void* payload, void (*dtor)(void*)) = NULL;
int (*mlx_closure_kwargs_set_ptr)(mlx_closure_kwargs* cls, const mlx_closure_kwargs src) = NULL;
int (*mlx_closure_kwargs_apply_ptr)(mlx_vector_array* res, mlx_closure_kwargs cls, const mlx_vector_array input_0, const mlx_map_string_to_array input_1) = NULL;
mlx_closure_value_and_grad (*mlx_closure_value_and_grad_new_ptr)(void) = NULL;
int (*mlx_closure_value_and_grad_free_ptr)(mlx_closure_value_and_grad cls) = NULL;
mlx_closure_value_and_grad (*mlx_closure_value_and_grad_new_func_ptr)(int (*fun)(mlx_vector_array*, mlx_vector_array*, const mlx_vector_array)) = NULL;
mlx_closure_value_and_grad (*mlx_closure_value_and_grad_new_func_payload_ptr)(int (*fun)( mlx_vector_array*, mlx_vector_array*, const mlx_vector_array, void*), void* payload, void (*dtor)(void*)) = NULL;
int (*mlx_closure_value_and_grad_set_ptr)(mlx_closure_value_and_grad* cls, const mlx_closure_value_and_grad src) = NULL;
int (*mlx_closure_value_and_grad_apply_ptr)(mlx_vector_array* res_0, mlx_vector_array* res_1, mlx_closure_value_and_grad cls, const mlx_vector_array input) = NULL;
mlx_closure_custom (*mlx_closure_custom_new_ptr)(void) = NULL;
int (*mlx_closure_custom_free_ptr)(mlx_closure_custom cls) = NULL;
mlx_closure_custom (*mlx_closure_custom_new_func_ptr)(int (*fun)( mlx_vector_array*, const mlx_vector_array, const mlx_vector_array, const mlx_vector_array)) = NULL;
mlx_closure_custom (*mlx_closure_custom_new_func_payload_ptr)(int (*fun)( mlx_vector_array*, const mlx_vector_array, const mlx_vector_array, const mlx_vector_array, void*), void* payload, void (*dtor)(void*)) = NULL;
int (*mlx_closure_custom_set_ptr)(mlx_closure_custom* cls, const mlx_closure_custom src) = NULL;
int (*mlx_closure_custom_apply_ptr)(mlx_vector_array* res, mlx_closure_custom cls, const mlx_vector_array input_0, const mlx_vector_array input_1, const mlx_vector_array input_2) = NULL;
mlx_closure_custom_jvp (*mlx_closure_custom_jvp_new_ptr)(void) = NULL;
int (*mlx_closure_custom_jvp_free_ptr)(mlx_closure_custom_jvp cls) = NULL;
mlx_closure_custom_jvp (*mlx_closure_custom_jvp_new_func_ptr)(int (*fun)( mlx_vector_array*, const mlx_vector_array, const mlx_vector_array, const int*, size_t _num)) = NULL;
mlx_closure_custom_jvp (*mlx_closure_custom_jvp_new_func_payload_ptr)(int (*fun)( mlx_vector_array*, const mlx_vector_array, const mlx_vector_array, const int*, size_t _num, void*), void* payload, void (*dtor)(void*)) = NULL;
int (*mlx_closure_custom_jvp_set_ptr)(mlx_closure_custom_jvp* cls, const mlx_closure_custom_jvp src) = NULL;
int (*mlx_closure_custom_jvp_apply_ptr)(mlx_vector_array* res, mlx_closure_custom_jvp cls, const mlx_vector_array input_0, const mlx_vector_array input_1, const int* input_2, size_t input_2_num) = NULL;
mlx_closure_custom_vmap (*mlx_closure_custom_vmap_new_ptr)(void) = NULL;
int (*mlx_closure_custom_vmap_free_ptr)(mlx_closure_custom_vmap cls) = NULL;
mlx_closure_custom_vmap (*mlx_closure_custom_vmap_new_func_ptr)(int (*fun)( mlx_vector_array*, mlx_vector_int*, const mlx_vector_array, const int*, size_t _num)) = NULL;
mlx_closure_custom_vmap (*mlx_closure_custom_vmap_new_func_payload_ptr)(int (*fun)( mlx_vector_array*, mlx_vector_int*, const mlx_vector_array, const int*, size_t _num, void*), void* payload, void (*dtor)(void*)) = NULL;
int (*mlx_closure_custom_vmap_set_ptr)(mlx_closure_custom_vmap* cls, const mlx_closure_custom_vmap src) = NULL;
int (*mlx_closure_custom_vmap_apply_ptr)(mlx_vector_array* res_0, mlx_vector_int* res_1, mlx_closure_custom_vmap cls, const mlx_vector_array input_0, const int* input_1, size_t input_1_num) = NULL;
int (*mlx_compile_ptr)(mlx_closure* res, const mlx_closure fun, bool shapeless) = NULL;
int (*mlx_detail_compile_ptr)(mlx_closure* res, const mlx_closure fun, uintptr_t fun_id, bool shapeless, const uint64_t* constants, size_t constants_num) = NULL;
int (*mlx_detail_compile_clear_cache_ptr)(void) = NULL;
int (*mlx_detail_compile_erase_ptr)(uintptr_t fun_id) = NULL;
int (*mlx_disable_compile_ptr)(void) = NULL;
int (*mlx_enable_compile_ptr)(void) = NULL;
int (*mlx_set_compile_mode_ptr)(mlx_compile_mode mode) = NULL;
mlx_device (*mlx_device_new_ptr)(void) = NULL;
mlx_device (*mlx_device_new_type_ptr)(mlx_device_type type, int index) = NULL;
int (*mlx_device_free_ptr)(mlx_device dev) = NULL;
int (*mlx_device_set_ptr)(mlx_device* dev, const mlx_device src) = NULL;
int (*mlx_device_tostring_ptr)(mlx_string* str, mlx_device dev) = NULL;
bool (*mlx_device_equal_ptr)(mlx_device lhs, mlx_device rhs) = NULL;
int (*mlx_device_get_index_ptr)(int* index, mlx_device dev) = NULL;
int (*mlx_device_get_type_ptr)(mlx_device_type* type, mlx_device dev) = NULL;
int (*mlx_get_default_device_ptr)(mlx_device* dev) = NULL;
int (*mlx_set_default_device_ptr)(mlx_device dev) = NULL;
int (*mlx_distributed_all_gather_ptr)(mlx_array* res, const mlx_array x, const mlx_distributed_group group , const mlx_stream S) = NULL;
int (*mlx_distributed_all_max_ptr)(mlx_array* res, const mlx_array x, const mlx_distributed_group group , const mlx_stream s) = NULL;
int (*mlx_distributed_all_min_ptr)(mlx_array* res, const mlx_array x, const mlx_distributed_group group , const mlx_stream s) = NULL;
int (*mlx_distributed_all_sum_ptr)(mlx_array* res, const mlx_array x, const mlx_distributed_group group , const mlx_stream s) = NULL;
int (*mlx_distributed_recv_ptr)(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, int src, const mlx_distributed_group group , const mlx_stream s) = NULL;
int (*mlx_distributed_recv_like_ptr)(mlx_array* res, const mlx_array x, int src, const mlx_distributed_group group , const mlx_stream s) = NULL;
int (*mlx_distributed_send_ptr)(mlx_array* res, const mlx_array x, int dst, const mlx_distributed_group group , const mlx_stream s) = NULL;
int (*mlx_distributed_sum_scatter_ptr)(mlx_array* res, const mlx_array x, const mlx_distributed_group group , const mlx_stream s) = NULL;
int (*mlx_distributed_group_rank_ptr)(mlx_distributed_group group) = NULL;
int (*mlx_distributed_group_size_ptr)(mlx_distributed_group group) = NULL;
mlx_distributed_group (*mlx_distributed_group_split_ptr)(mlx_distributed_group group, int color, int key) = NULL;
bool (*mlx_distributed_is_available_ptr)(void) = NULL;
mlx_distributed_group (*mlx_distributed_init_ptr)(bool strict) = NULL;
void (*mlx_set_error_handler_ptr)(mlx_error_handler_func handler, void* data, void (*dtor)(void*)) = NULL;
void (*_mlx_error_ptr)(const char* file, const int line, const char* fmt, ...) = NULL;
int (*mlx_export_function_ptr)(const char* file, const mlx_closure fun, const mlx_vector_array args, bool shapeless) = NULL;
int (*mlx_export_function_kwargs_ptr)(const char* file, const mlx_closure_kwargs fun, const mlx_vector_array args, const mlx_map_string_to_array kwargs, bool shapeless) = NULL;
mlx_function_exporter (*mlx_function_exporter_new_ptr)(const char* file, const mlx_closure fun, bool shapeless) = NULL;
int (*mlx_function_exporter_free_ptr)(mlx_function_exporter xfunc) = NULL;
int (*mlx_function_exporter_apply_ptr)(const mlx_function_exporter xfunc, const mlx_vector_array args) = NULL;
int (*mlx_function_exporter_apply_kwargs_ptr)(const mlx_function_exporter xfunc, const mlx_vector_array args, const mlx_map_string_to_array kwargs) = NULL;
mlx_imported_function (*mlx_imported_function_new_ptr)(const char* file) = NULL;
int (*mlx_imported_function_free_ptr)(mlx_imported_function xfunc) = NULL;
int (*mlx_imported_function_apply_ptr)(mlx_vector_array* res, const mlx_imported_function xfunc, const mlx_vector_array args) = NULL;
int (*mlx_imported_function_apply_kwargs_ptr)(mlx_vector_array* res, const mlx_imported_function xfunc, const mlx_vector_array args, const mlx_map_string_to_array kwargs) = NULL;
mlx_fast_cuda_kernel_config (*mlx_fast_cuda_kernel_config_new_ptr)(void) = NULL;
void (*mlx_fast_cuda_kernel_config_free_ptr)(mlx_fast_cuda_kernel_config cls) = NULL;
int (*mlx_fast_cuda_kernel_config_add_output_arg_ptr)(mlx_fast_cuda_kernel_config cls, const int* shape, size_t size, mlx_dtype dtype) = NULL;
int (*mlx_fast_cuda_kernel_config_set_grid_ptr)(mlx_fast_cuda_kernel_config cls, int grid1, int grid2, int grid3) = NULL;
int (*mlx_fast_cuda_kernel_config_set_thread_group_ptr)(mlx_fast_cuda_kernel_config cls, int thread1, int thread2, int thread3) = NULL;
int (*mlx_fast_cuda_kernel_config_set_init_value_ptr)(mlx_fast_cuda_kernel_config cls, float value) = NULL;
int (*mlx_fast_cuda_kernel_config_set_verbose_ptr)(mlx_fast_cuda_kernel_config cls, bool verbose) = NULL;
int (*mlx_fast_cuda_kernel_config_add_template_arg_dtype_ptr)(mlx_fast_cuda_kernel_config cls, const char* name, mlx_dtype dtype) = NULL;
int (*mlx_fast_cuda_kernel_config_add_template_arg_int_ptr)(mlx_fast_cuda_kernel_config cls, const char* name, int value) = NULL;
int (*mlx_fast_cuda_kernel_config_add_template_arg_bool_ptr)(mlx_fast_cuda_kernel_config cls, const char* name, bool value) = NULL;
mlx_fast_cuda_kernel (*mlx_fast_cuda_kernel_new_ptr)(const char* name, const mlx_vector_string input_names, const mlx_vector_string output_names, const char* source, const char* header, bool ensure_row_contiguous, int shared_memory) = NULL;
void (*mlx_fast_cuda_kernel_free_ptr)(mlx_fast_cuda_kernel cls) = NULL;
int (*mlx_fast_cuda_kernel_apply_ptr)(mlx_vector_array* outputs, mlx_fast_cuda_kernel cls, const mlx_vector_array inputs, const mlx_fast_cuda_kernel_config config, const mlx_stream stream) = NULL;
int (*mlx_fast_layer_norm_ptr)(mlx_array* res, const mlx_array x, const mlx_array weight , const mlx_array bias , float eps, const mlx_stream s) = NULL;
mlx_fast_metal_kernel_config (*mlx_fast_metal_kernel_config_new_ptr)(void) = NULL;
void (*mlx_fast_metal_kernel_config_free_ptr)(mlx_fast_metal_kernel_config cls) = NULL;
int (*mlx_fast_metal_kernel_config_add_output_arg_ptr)(mlx_fast_metal_kernel_config cls, const int* shape, size_t size, mlx_dtype dtype) = NULL;
int (*mlx_fast_metal_kernel_config_set_grid_ptr)(mlx_fast_metal_kernel_config cls, int grid1, int grid2, int grid3) = NULL;
int (*mlx_fast_metal_kernel_config_set_thread_group_ptr)(mlx_fast_metal_kernel_config cls, int thread1, int thread2, int thread3) = NULL;
int (*mlx_fast_metal_kernel_config_set_init_value_ptr)(mlx_fast_metal_kernel_config cls, float value) = NULL;
int (*mlx_fast_metal_kernel_config_set_verbose_ptr)(mlx_fast_metal_kernel_config cls, bool verbose) = NULL;
int (*mlx_fast_metal_kernel_config_add_template_arg_dtype_ptr)(mlx_fast_metal_kernel_config cls, const char* name, mlx_dtype dtype) = NULL;
int (*mlx_fast_metal_kernel_config_add_template_arg_int_ptr)(mlx_fast_metal_kernel_config cls, const char* name, int value) = NULL;
int (*mlx_fast_metal_kernel_config_add_template_arg_bool_ptr)(mlx_fast_metal_kernel_config cls, const char* name, bool value) = NULL;
mlx_fast_metal_kernel (*mlx_fast_metal_kernel_new_ptr)(const char* name, const mlx_vector_string input_names, const mlx_vector_string output_names, const char* source, const char* header, bool ensure_row_contiguous, bool atomic_outputs) = NULL;
void (*mlx_fast_metal_kernel_free_ptr)(mlx_fast_metal_kernel cls) = NULL;
int (*mlx_fast_metal_kernel_apply_ptr)(mlx_vector_array* outputs, mlx_fast_metal_kernel cls, const mlx_vector_array inputs, const mlx_fast_metal_kernel_config config, const mlx_stream stream) = NULL;
int (*mlx_fast_rms_norm_ptr)(mlx_array* res, const mlx_array x, const mlx_array weight , float eps, const mlx_stream s) = NULL;
int (*mlx_fast_rope_ptr)(mlx_array* res, const mlx_array x, int dims, bool traditional, mlx_optional_float base, float scale, int offset, const mlx_array freqs , const mlx_stream s) = NULL;
int (*mlx_fast_rope_dynamic_ptr)(mlx_array* res, const mlx_array x, int dims, bool traditional, mlx_optional_float base, float scale, const mlx_array offset, const mlx_array freqs , const mlx_stream s) = NULL;
int (*mlx_fast_scaled_dot_product_attention_ptr)(mlx_array* res, const mlx_array queries, const mlx_array keys, const mlx_array values, float scale, const char* mask_mode, const mlx_array mask_arr , const mlx_array sinks , const mlx_stream s) = NULL;
int (*mlx_fft_fft_ptr)(mlx_array* res, const mlx_array a, int n, int axis, const mlx_stream s) = NULL;
int (*mlx_fft_fft2_ptr)(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_fft_fftn_ptr)(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_fft_fftshift_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_fft_ifft_ptr)(mlx_array* res, const mlx_array a, int n, int axis, const mlx_stream s) = NULL;
int (*mlx_fft_ifft2_ptr)(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_fft_ifftn_ptr)(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_fft_ifftshift_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_fft_irfft_ptr)(mlx_array* res, const mlx_array a, int n, int axis, const mlx_stream s) = NULL;
int (*mlx_fft_irfft2_ptr)(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_fft_irfftn_ptr)(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_fft_rfft_ptr)(mlx_array* res, const mlx_array a, int n, int axis, const mlx_stream s) = NULL;
int (*mlx_fft_rfft2_ptr)(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_fft_rfftn_ptr)(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_load_reader_ptr)(mlx_array* res, mlx_io_reader in_stream, const mlx_stream s) = NULL;
int (*mlx_load_ptr)(mlx_array* res, const char* file, const mlx_stream s) = NULL;
int (*mlx_load_safetensors_reader_ptr)(mlx_map_string_to_array* res_0, mlx_map_string_to_string* res_1, mlx_io_reader in_stream, const mlx_stream s) = NULL;
int (*mlx_load_safetensors_ptr)(mlx_map_string_to_array* res_0, mlx_map_string_to_string* res_1, const char* file, const mlx_stream s) = NULL;
int (*mlx_save_writer_ptr)(mlx_io_writer out_stream, const mlx_array a) = NULL;
int (*mlx_save_ptr)(const char* file, const mlx_array a) = NULL;
int (*mlx_save_safetensors_writer_ptr)(mlx_io_writer in_stream, const mlx_map_string_to_array param, const mlx_map_string_to_string metadata) = NULL;
int (*mlx_save_safetensors_ptr)(const char* file, const mlx_map_string_to_array param, const mlx_map_string_to_string metadata) = NULL;
mlx_io_reader (*mlx_io_reader_new_ptr)(void* desc, mlx_io_vtable vtable) = NULL;
int (*mlx_io_reader_descriptor_ptr)(void** desc_, mlx_io_reader io) = NULL;
int (*mlx_io_reader_tostring_ptr)(mlx_string* str_, mlx_io_reader io) = NULL;
int (*mlx_io_reader_free_ptr)(mlx_io_reader io) = NULL;
mlx_io_writer (*mlx_io_writer_new_ptr)(void* desc, mlx_io_vtable vtable) = NULL;
int (*mlx_io_writer_descriptor_ptr)(void** desc_, mlx_io_writer io) = NULL;
int (*mlx_io_writer_tostring_ptr)(mlx_string* str_, mlx_io_writer io) = NULL;
int (*mlx_io_writer_free_ptr)(mlx_io_writer io) = NULL;
int (*mlx_linalg_cholesky_ptr)(mlx_array* res, const mlx_array a, bool upper, const mlx_stream s) = NULL;
int (*mlx_linalg_cholesky_inv_ptr)(mlx_array* res, const mlx_array a, bool upper, const mlx_stream s) = NULL;
int (*mlx_linalg_cross_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, int axis, const mlx_stream s) = NULL;
int (*mlx_linalg_eig_ptr)(mlx_array* res_0, mlx_array* res_1, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_linalg_eigh_ptr)(mlx_array* res_0, mlx_array* res_1, const mlx_array a, const char* UPLO, const mlx_stream s) = NULL;
int (*mlx_linalg_eigvals_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_linalg_eigvalsh_ptr)(mlx_array* res, const mlx_array a, const char* UPLO, const mlx_stream s) = NULL;
int (*mlx_linalg_inv_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_linalg_lu_ptr)(mlx_vector_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_linalg_lu_factor_ptr)(mlx_array* res_0, mlx_array* res_1, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_linalg_norm_ptr)(mlx_array* res, const mlx_array a, double ord, const int* axis , size_t axis_num, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_linalg_norm_matrix_ptr)(mlx_array* res, const mlx_array a, const char* ord, const int* axis , size_t axis_num, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_linalg_norm_l2_ptr)(mlx_array* res, const mlx_array a, const int* axis , size_t axis_num, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_linalg_pinv_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_linalg_qr_ptr)(mlx_array* res_0, mlx_array* res_1, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_linalg_solve_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_linalg_solve_triangular_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, bool upper, const mlx_stream s) = NULL;
int (*mlx_linalg_svd_ptr)(mlx_vector_array* res, const mlx_array a, bool compute_uv, const mlx_stream s) = NULL;
int (*mlx_linalg_tri_inv_ptr)(mlx_array* res, const mlx_array a, bool upper, const mlx_stream s) = NULL;
mlx_map_string_to_array (*mlx_map_string_to_array_new_ptr)(void) = NULL;
int (*mlx_map_string_to_array_set_ptr)(mlx_map_string_to_array* map, const mlx_map_string_to_array src) = NULL;
int (*mlx_map_string_to_array_free_ptr)(mlx_map_string_to_array map) = NULL;
int (*mlx_map_string_to_array_insert_ptr)(mlx_map_string_to_array map, const char* key, const mlx_array value) = NULL;
int (*mlx_map_string_to_array_get_ptr)(mlx_array* value, const mlx_map_string_to_array map, const char* key) = NULL;
mlx_map_string_to_array_iterator (*mlx_map_string_to_array_iterator_new_ptr)(mlx_map_string_to_array map) = NULL;
int (*mlx_map_string_to_array_iterator_free_ptr)(mlx_map_string_to_array_iterator it) = NULL;
int (*mlx_map_string_to_array_iterator_next_ptr)(const char** key, mlx_array* value, mlx_map_string_to_array_iterator it) = NULL;
mlx_map_string_to_string (*mlx_map_string_to_string_new_ptr)(void) = NULL;
int (*mlx_map_string_to_string_set_ptr)(mlx_map_string_to_string* map, const mlx_map_string_to_string src) = NULL;
int (*mlx_map_string_to_string_free_ptr)(mlx_map_string_to_string map) = NULL;
int (*mlx_map_string_to_string_insert_ptr)(mlx_map_string_to_string map, const char* key, const char* value) = NULL;
int (*mlx_map_string_to_string_get_ptr)(const char** value, const mlx_map_string_to_string map, const char* key) = NULL;
mlx_map_string_to_string_iterator (*mlx_map_string_to_string_iterator_new_ptr)(mlx_map_string_to_string map) = NULL;
int (*mlx_map_string_to_string_iterator_free_ptr)(mlx_map_string_to_string_iterator it) = NULL;
int (*mlx_map_string_to_string_iterator_next_ptr)(const char** key, const char** value, mlx_map_string_to_string_iterator it) = NULL;
int (*mlx_clear_cache_ptr)(void) = NULL;
int (*mlx_get_active_memory_ptr)(size_t* res) = NULL;
int (*mlx_get_cache_memory_ptr)(size_t* res) = NULL;
int (*mlx_get_memory_limit_ptr)(size_t* res) = NULL;
int (*mlx_get_peak_memory_ptr)(size_t* res) = NULL;
int (*mlx_reset_peak_memory_ptr)(void) = NULL;
int (*mlx_set_cache_limit_ptr)(size_t* res, size_t limit) = NULL;
int (*mlx_set_memory_limit_ptr)(size_t* res, size_t limit) = NULL;
int (*mlx_set_wired_limit_ptr)(size_t* res, size_t limit) = NULL;
mlx_metal_device_info_t (*mlx_metal_device_info_ptr)(void) = NULL;
int (*mlx_metal_is_available_ptr)(bool* res) = NULL;
int (*mlx_metal_start_capture_ptr)(const char* path) = NULL;
int (*mlx_metal_stop_capture_ptr)(void) = NULL;
int (*mlx_abs_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_add_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_addmm_ptr)(mlx_array* res, const mlx_array c, const mlx_array a, const mlx_array b, float alpha, float beta, const mlx_stream s) = NULL;
int (*mlx_all_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_all_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_all_ptr)(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_allclose_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, double rtol, double atol, bool equal_nan, const mlx_stream s) = NULL;
int (*mlx_any_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_any_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_any_ptr)(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_arange_ptr)(mlx_array* res, double start, double stop, double step, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_arccos_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_arccosh_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_arcsin_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_arcsinh_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_arctan_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_arctan2_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_arctanh_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_argmax_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_argmax_ptr)(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_argmin_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_argmin_ptr)(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_argpartition_axis_ptr)(mlx_array* res, const mlx_array a, int kth, int axis, const mlx_stream s) = NULL;
int (*mlx_argpartition_ptr)(mlx_array* res, const mlx_array a, int kth, const mlx_stream s) = NULL;
int (*mlx_argsort_axis_ptr)(mlx_array* res, const mlx_array a, int axis, const mlx_stream s) = NULL;
int (*mlx_argsort_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_array_equal_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, bool equal_nan, const mlx_stream s) = NULL;
int (*mlx_as_strided_ptr)(mlx_array* res, const mlx_array a, const int* shape, size_t shape_num, const int64_t* strides, size_t strides_num, size_t offset, const mlx_stream s) = NULL;
int (*mlx_astype_ptr)(mlx_array* res, const mlx_array a, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_atleast_1d_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_atleast_2d_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_atleast_3d_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_bitwise_and_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_bitwise_invert_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_bitwise_or_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_bitwise_xor_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_block_masked_mm_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, int block_size, const mlx_array mask_out , const mlx_array mask_lhs , const mlx_array mask_rhs , const mlx_stream s) = NULL;
int (*mlx_broadcast_arrays_ptr)(mlx_vector_array* res, const mlx_vector_array inputs, const mlx_stream s) = NULL;
int (*mlx_broadcast_to_ptr)(mlx_array* res, const mlx_array a, const int* shape, size_t shape_num, const mlx_stream s) = NULL;
int (*mlx_ceil_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_clip_ptr)(mlx_array* res, const mlx_array a, const mlx_array a_min , const mlx_array a_max , const mlx_stream s) = NULL;
int (*mlx_concatenate_axis_ptr)(mlx_array* res, const mlx_vector_array arrays, int axis, const mlx_stream s) = NULL;
int (*mlx_concatenate_ptr)(mlx_array* res, const mlx_vector_array arrays, const mlx_stream s) = NULL;
int (*mlx_conjugate_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_contiguous_ptr)(mlx_array* res, const mlx_array a, bool allow_col_major, const mlx_stream s) = NULL;
int (*mlx_conv1d_ptr)(mlx_array* res, const mlx_array input, const mlx_array weight, int stride, int padding, int dilation, int groups, const mlx_stream s) = NULL;
int (*mlx_conv2d_ptr)(mlx_array* res, const mlx_array input, const mlx_array weight, int stride_0, int stride_1, int padding_0, int padding_1, int dilation_0, int dilation_1, int groups, const mlx_stream s) = NULL;
int (*mlx_conv3d_ptr)(mlx_array* res, const mlx_array input, const mlx_array weight, int stride_0, int stride_1, int stride_2, int padding_0, int padding_1, int padding_2, int dilation_0, int dilation_1, int dilation_2, int groups, const mlx_stream s) = NULL;
int (*mlx_conv_general_ptr)(mlx_array* res, const mlx_array input, const mlx_array weight, const int* stride, size_t stride_num, const int* padding_lo, size_t padding_lo_num, const int* padding_hi, size_t padding_hi_num, const int* kernel_dilation, size_t kernel_dilation_num, const int* input_dilation, size_t input_dilation_num, int groups, bool flip, const mlx_stream s) = NULL;
int (*mlx_conv_transpose1d_ptr)(mlx_array* res, const mlx_array input, const mlx_array weight, int stride, int padding, int dilation, int output_padding, int groups, const mlx_stream s) = NULL;
int (*mlx_conv_transpose2d_ptr)(mlx_array* res, const mlx_array input, const mlx_array weight, int stride_0, int stride_1, int padding_0, int padding_1, int dilation_0, int dilation_1, int output_padding_0, int output_padding_1, int groups, const mlx_stream s) = NULL;
int (*mlx_conv_transpose3d_ptr)(mlx_array* res, const mlx_array input, const mlx_array weight, int stride_0, int stride_1, int stride_2, int padding_0, int padding_1, int padding_2, int dilation_0, int dilation_1, int dilation_2, int output_padding_0, int output_padding_1, int output_padding_2, int groups, const mlx_stream s) = NULL;
int (*mlx_copy_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_cos_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_cosh_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_cummax_ptr)(mlx_array* res, const mlx_array a, int axis, bool reverse, bool inclusive, const mlx_stream s) = NULL;
int (*mlx_cummin_ptr)(mlx_array* res, const mlx_array a, int axis, bool reverse, bool inclusive, const mlx_stream s) = NULL;
int (*mlx_cumprod_ptr)(mlx_array* res, const mlx_array a, int axis, bool reverse, bool inclusive, const mlx_stream s) = NULL;
int (*mlx_cumsum_ptr)(mlx_array* res, const mlx_array a, int axis, bool reverse, bool inclusive, const mlx_stream s) = NULL;
int (*mlx_degrees_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_depends_ptr)(mlx_vector_array* res, const mlx_vector_array inputs, const mlx_vector_array dependencies) = NULL;
int (*mlx_dequantize_ptr)(mlx_array* res, const mlx_array w, const mlx_array scales, const mlx_array biases , mlx_optional_int group_size, mlx_optional_int bits, const char* mode, mlx_optional_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_diag_ptr)(mlx_array* res, const mlx_array a, int k, const mlx_stream s) = NULL;
int (*mlx_diagonal_ptr)(mlx_array* res, const mlx_array a, int offset, int axis1, int axis2, const mlx_stream s) = NULL;
int (*mlx_divide_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_divmod_ptr)(mlx_vector_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_einsum_ptr)(mlx_array* res, const char* subscripts, const mlx_vector_array operands, const mlx_stream s) = NULL;
int (*mlx_equal_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_erf_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_erfinv_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_exp_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_expand_dims_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_expand_dims_ptr)(mlx_array* res, const mlx_array a, int axis, const mlx_stream s) = NULL;
int (*mlx_expm1_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_eye_ptr)(mlx_array* res, int n, int m, int k, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_flatten_ptr)(mlx_array* res, const mlx_array a, int start_axis, int end_axis, const mlx_stream s) = NULL;
int (*mlx_floor_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_floor_divide_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_from_fp8_ptr)(mlx_array* res, const mlx_array x, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_full_ptr)(mlx_array* res, const int* shape, size_t shape_num, const mlx_array vals, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_full_like_ptr)(mlx_array* res, const mlx_array a, const mlx_array vals, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_gather_ptr)(mlx_array* res, const mlx_array a, const mlx_vector_array indices, const int* axes, size_t axes_num, const int* slice_sizes, size_t slice_sizes_num, const mlx_stream s) = NULL;
int (*mlx_gather_single_ptr)(mlx_array* res, const mlx_array a, const mlx_array indices, int axis, const int* slice_sizes, size_t slice_sizes_num, const mlx_stream s) = NULL;
int (*mlx_gather_mm_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_array lhs_indices , const mlx_array rhs_indices , bool sorted_indices, const mlx_stream s) = NULL;
int (*mlx_gather_qmm_ptr)(mlx_array* res, const mlx_array x, const mlx_array w, const mlx_array scales, const mlx_array biases , const mlx_array lhs_indices , const mlx_array rhs_indices , bool transpose, mlx_optional_int group_size, mlx_optional_int bits, const char* mode, bool sorted_indices, const mlx_stream s) = NULL;
int (*mlx_greater_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_greater_equal_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_hadamard_transform_ptr)(mlx_array* res, const mlx_array a, mlx_optional_float scale, const mlx_stream s) = NULL;
int (*mlx_identity_ptr)(mlx_array* res, int n, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_imag_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_inner_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_isclose_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, double rtol, double atol, bool equal_nan, const mlx_stream s) = NULL;
int (*mlx_isfinite_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_isinf_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_isnan_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_isneginf_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_isposinf_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_kron_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_left_shift_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_less_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_less_equal_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_linspace_ptr)(mlx_array* res, double start, double stop, int num, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_log_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_log10_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_log1p_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_log2_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_logaddexp_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_logcumsumexp_ptr)(mlx_array* res, const mlx_array a, int axis, bool reverse, bool inclusive, const mlx_stream s) = NULL;
int (*mlx_logical_and_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_logical_not_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_logical_or_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_logsumexp_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_logsumexp_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_logsumexp_ptr)(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_masked_scatter_ptr)(mlx_array* res, const mlx_array a, const mlx_array mask, const mlx_array src, const mlx_stream s) = NULL;
int (*mlx_matmul_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_max_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_max_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_max_ptr)(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_maximum_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_mean_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_mean_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_mean_ptr)(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_median_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_meshgrid_ptr)(mlx_vector_array* res, const mlx_vector_array arrays, bool sparse, const char* indexing, const mlx_stream s) = NULL;
int (*mlx_min_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_min_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_min_ptr)(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_minimum_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_moveaxis_ptr)(mlx_array* res, const mlx_array a, int source, int destination, const mlx_stream s) = NULL;
int (*mlx_multiply_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_nan_to_num_ptr)(mlx_array* res, const mlx_array a, float nan, mlx_optional_float posinf, mlx_optional_float neginf, const mlx_stream s) = NULL;
int (*mlx_negative_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_not_equal_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_number_of_elements_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool inverted, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_ones_ptr)(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_ones_like_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_outer_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_pad_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, const int* low_pad_size, size_t low_pad_size_num, const int* high_pad_size, size_t high_pad_size_num, const mlx_array pad_value, const char* mode, const mlx_stream s) = NULL;
int (*mlx_pad_symmetric_ptr)(mlx_array* res, const mlx_array a, int pad_width, const mlx_array pad_value, const char* mode, const mlx_stream s) = NULL;
int (*mlx_partition_axis_ptr)(mlx_array* res, const mlx_array a, int kth, int axis, const mlx_stream s) = NULL;
int (*mlx_partition_ptr)(mlx_array* res, const mlx_array a, int kth, const mlx_stream s) = NULL;
int (*mlx_power_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_prod_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_prod_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_prod_ptr)(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_put_along_axis_ptr)(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array values, int axis, const mlx_stream s) = NULL;
int (*mlx_qqmm_ptr)(mlx_array* res, const mlx_array x, const mlx_array w, const mlx_array w_scales , mlx_optional_int group_size, mlx_optional_int bits, const char* mode, const mlx_stream s) = NULL;
int (*mlx_quantize_ptr)(mlx_vector_array* res, const mlx_array w, mlx_optional_int group_size, mlx_optional_int bits, const char* mode, const mlx_stream s) = NULL;
int (*mlx_quantized_matmul_ptr)(mlx_array* res, const mlx_array x, const mlx_array w, const mlx_array scales, const mlx_array biases , bool transpose, mlx_optional_int group_size, mlx_optional_int bits, const char* mode, const mlx_stream s) = NULL;
int (*mlx_radians_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_real_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_reciprocal_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_remainder_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_repeat_axis_ptr)(mlx_array* res, const mlx_array arr, int repeats, int axis, const mlx_stream s) = NULL;
int (*mlx_repeat_ptr)(mlx_array* res, const mlx_array arr, int repeats, const mlx_stream s) = NULL;
int (*mlx_reshape_ptr)(mlx_array* res, const mlx_array a, const int* shape, size_t shape_num, const mlx_stream s) = NULL;
int (*mlx_right_shift_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_roll_axis_ptr)(mlx_array* res, const mlx_array a, const int* shift, size_t shift_num, int axis, const mlx_stream s) = NULL;
int (*mlx_roll_axes_ptr)(mlx_array* res, const mlx_array a, const int* shift, size_t shift_num, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_roll_ptr)(mlx_array* res, const mlx_array a, const int* shift, size_t shift_num, const mlx_stream s) = NULL;
int (*mlx_round_ptr)(mlx_array* res, const mlx_array a, int decimals, const mlx_stream s) = NULL;
int (*mlx_rsqrt_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_scatter_ptr)(mlx_array* res, const mlx_array a, const mlx_vector_array indices, const mlx_array updates, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_scatter_single_ptr)(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array updates, int axis, const mlx_stream s) = NULL;
int (*mlx_scatter_add_ptr)(mlx_array* res, const mlx_array a, const mlx_vector_array indices, const mlx_array updates, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_scatter_add_single_ptr)(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array updates, int axis, const mlx_stream s) = NULL;
int (*mlx_scatter_add_axis_ptr)(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array values, int axis, const mlx_stream s) = NULL;
int (*mlx_scatter_max_ptr)(mlx_array* res, const mlx_array a, const mlx_vector_array indices, const mlx_array updates, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_scatter_max_single_ptr)(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array updates, int axis, const mlx_stream s) = NULL;
int (*mlx_scatter_min_ptr)(mlx_array* res, const mlx_array a, const mlx_vector_array indices, const mlx_array updates, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_scatter_min_single_ptr)(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array updates, int axis, const mlx_stream s) = NULL;
int (*mlx_scatter_prod_ptr)(mlx_array* res, const mlx_array a, const mlx_vector_array indices, const mlx_array updates, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_scatter_prod_single_ptr)(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array updates, int axis, const mlx_stream s) = NULL;
int (*mlx_segmented_mm_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_array segments, const mlx_stream s) = NULL;
int (*mlx_sigmoid_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_sign_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_sin_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_sinh_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_slice_ptr)(mlx_array* res, const mlx_array a, const int* start, size_t start_num, const int* stop, size_t stop_num, const int* strides, size_t strides_num, const mlx_stream s) = NULL;
int (*mlx_slice_dynamic_ptr)(mlx_array* res, const mlx_array a, const mlx_array start, const int* axes, size_t axes_num, const int* slice_size, size_t slice_size_num, const mlx_stream s) = NULL;
int (*mlx_slice_update_ptr)(mlx_array* res, const mlx_array src, const mlx_array update, const int* start, size_t start_num, const int* stop, size_t stop_num, const int* strides, size_t strides_num, const mlx_stream s) = NULL;
int (*mlx_slice_update_dynamic_ptr)(mlx_array* res, const mlx_array src, const mlx_array update, const mlx_array start, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_softmax_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool precise, const mlx_stream s) = NULL;
int (*mlx_softmax_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool precise, const mlx_stream s) = NULL;
int (*mlx_softmax_ptr)(mlx_array* res, const mlx_array a, bool precise, const mlx_stream s) = NULL;
int (*mlx_sort_axis_ptr)(mlx_array* res, const mlx_array a, int axis, const mlx_stream s) = NULL;
int (*mlx_sort_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_split_ptr)(mlx_vector_array* res, const mlx_array a, int num_splits, int axis, const mlx_stream s) = NULL;
int (*mlx_split_sections_ptr)(mlx_vector_array* res, const mlx_array a, const int* indices, size_t indices_num, int axis, const mlx_stream s) = NULL;
int (*mlx_sqrt_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_square_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_squeeze_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_squeeze_axis_ptr)(mlx_array* res, const mlx_array a, int axis, const mlx_stream s) = NULL;
int (*mlx_squeeze_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_stack_axis_ptr)(mlx_array* res, const mlx_vector_array arrays, int axis, const mlx_stream s) = NULL;
int (*mlx_stack_ptr)(mlx_array* res, const mlx_vector_array arrays, const mlx_stream s) = NULL;
int (*mlx_std_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, int ddof, const mlx_stream s) = NULL;
int (*mlx_std_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool keepdims, int ddof, const mlx_stream s) = NULL;
int (*mlx_std_ptr)(mlx_array* res, const mlx_array a, bool keepdims, int ddof, const mlx_stream s) = NULL;
int (*mlx_stop_gradient_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_subtract_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) = NULL;
int (*mlx_sum_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_sum_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_sum_ptr)(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) = NULL;
int (*mlx_swapaxes_ptr)(mlx_array* res, const mlx_array a, int axis1, int axis2, const mlx_stream s) = NULL;
int (*mlx_take_axis_ptr)(mlx_array* res, const mlx_array a, const mlx_array indices, int axis, const mlx_stream s) = NULL;
int (*mlx_take_ptr)(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_stream s) = NULL;
int (*mlx_take_along_axis_ptr)(mlx_array* res, const mlx_array a, const mlx_array indices, int axis, const mlx_stream s) = NULL;
int (*mlx_tan_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_tanh_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_tensordot_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, const int* axes_a, size_t axes_a_num, const int* axes_b, size_t axes_b_num, const mlx_stream s) = NULL;
int (*mlx_tensordot_axis_ptr)(mlx_array* res, const mlx_array a, const mlx_array b, int axis, const mlx_stream s) = NULL;
int (*mlx_tile_ptr)(mlx_array* res, const mlx_array arr, const int* reps, size_t reps_num, const mlx_stream s) = NULL;
int (*mlx_to_fp8_ptr)(mlx_array* res, const mlx_array x, const mlx_stream s) = NULL;
int (*mlx_topk_axis_ptr)(mlx_array* res, const mlx_array a, int k, int axis, const mlx_stream s) = NULL;
int (*mlx_topk_ptr)(mlx_array* res, const mlx_array a, int k, const mlx_stream s) = NULL;
int (*mlx_trace_ptr)(mlx_array* res, const mlx_array a, int offset, int axis1, int axis2, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_transpose_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, const mlx_stream s) = NULL;
int (*mlx_transpose_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_tri_ptr)(mlx_array* res, int n, int m, int k, mlx_dtype type, const mlx_stream s) = NULL;
int (*mlx_tril_ptr)(mlx_array* res, const mlx_array x, int k, const mlx_stream s) = NULL;
int (*mlx_triu_ptr)(mlx_array* res, const mlx_array x, int k, const mlx_stream s) = NULL;
int (*mlx_unflatten_ptr)(mlx_array* res, const mlx_array a, int axis, const int* shape, size_t shape_num, const mlx_stream s) = NULL;
int (*mlx_var_axes_ptr)(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, int ddof, const mlx_stream s) = NULL;
int (*mlx_var_axis_ptr)(mlx_array* res, const mlx_array a, int axis, bool keepdims, int ddof, const mlx_stream s) = NULL;
int (*mlx_var_ptr)(mlx_array* res, const mlx_array a, bool keepdims, int ddof, const mlx_stream s) = NULL;
int (*mlx_view_ptr)(mlx_array* res, const mlx_array a, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_where_ptr)(mlx_array* res, const mlx_array condition, const mlx_array x, const mlx_array y, const mlx_stream s) = NULL;
int (*mlx_zeros_ptr)(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_stream s) = NULL;
int (*mlx_zeros_like_ptr)(mlx_array* res, const mlx_array a, const mlx_stream s) = NULL;
int (*mlx_random_bernoulli_ptr)(mlx_array* res, const mlx_array p, const int* shape, size_t shape_num, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_bits_ptr)(mlx_array* res, const int* shape, size_t shape_num, int width, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_categorical_shape_ptr)(mlx_array* res, const mlx_array logits, int axis, const int* shape, size_t shape_num, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_categorical_num_samples_ptr)(mlx_array* res, const mlx_array logits_, int axis, int num_samples, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_categorical_ptr)(mlx_array* res, const mlx_array logits, int axis, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_gumbel_ptr)(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_key_ptr)(mlx_array* res, uint64_t seed) = NULL;
int (*mlx_random_laplace_ptr)(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, float loc, float scale, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_multivariate_normal_ptr)(mlx_array* res, const mlx_array mean, const mlx_array cov, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_normal_broadcast_ptr)(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_array loc , const mlx_array scale , const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_normal_ptr)(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, float loc, float scale, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_permutation_ptr)(mlx_array* res, const mlx_array x, int axis, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_permutation_arange_ptr)(mlx_array* res, int x, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_randint_ptr)(mlx_array* res, const mlx_array low, const mlx_array high, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_seed_ptr)(uint64_t seed) = NULL;
int (*mlx_random_split_num_ptr)(mlx_array* res, const mlx_array key, int num, const mlx_stream s) = NULL;
int (*mlx_random_split_ptr)(mlx_array* res_0, mlx_array* res_1, const mlx_array key, const mlx_stream s) = NULL;
int (*mlx_random_truncated_normal_ptr)(mlx_array* res, const mlx_array lower, const mlx_array upper, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_array key , const mlx_stream s) = NULL;
int (*mlx_random_uniform_ptr)(mlx_array* res, const mlx_array low, const mlx_array high, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_array key , const mlx_stream s) = NULL;
mlx_stream (*mlx_stream_new_ptr)(void) = NULL;
mlx_stream (*mlx_stream_new_device_ptr)(mlx_device dev) = NULL;
int (*mlx_stream_set_ptr)(mlx_stream* stream, const mlx_stream src) = NULL;
int (*mlx_stream_free_ptr)(mlx_stream stream) = NULL;
int (*mlx_stream_tostring_ptr)(mlx_string* str, mlx_stream stream) = NULL;
bool (*mlx_stream_equal_ptr)(mlx_stream lhs, mlx_stream rhs) = NULL;
int (*mlx_stream_get_device_ptr)(mlx_device* dev, mlx_stream stream) = NULL;
int (*mlx_stream_get_index_ptr)(int* index, mlx_stream stream) = NULL;
int (*mlx_synchronize_ptr)(mlx_stream stream) = NULL;
int (*mlx_get_default_stream_ptr)(mlx_stream* stream, mlx_device dev) = NULL;
int (*mlx_set_default_stream_ptr)(mlx_stream stream) = NULL;
mlx_stream (*mlx_default_cpu_stream_new_ptr)(void) = NULL;
mlx_stream (*mlx_default_gpu_stream_new_ptr)(void) = NULL;
mlx_string (*mlx_string_new_ptr)(void) = NULL;
mlx_string (*mlx_string_new_data_ptr)(const char* str) = NULL;
int (*mlx_string_set_ptr)(mlx_string* str, const mlx_string src) = NULL;
const char* (*mlx_string_data_ptr)(mlx_string str) = NULL;
int (*mlx_string_free_ptr)(mlx_string str) = NULL;
int (*mlx_async_eval_ptr)(const mlx_vector_array outputs) = NULL;
int (*mlx_checkpoint_ptr)(mlx_closure* res, const mlx_closure fun) = NULL;
int (*mlx_custom_function_ptr)(mlx_closure* res, const mlx_closure fun, const mlx_closure_custom fun_vjp , const mlx_closure_custom_jvp fun_jvp , const mlx_closure_custom_vmap fun_vmap) = NULL;
int (*mlx_custom_vjp_ptr)(mlx_closure* res, const mlx_closure fun, const mlx_closure_custom fun_vjp) = NULL;
int (*mlx_eval_ptr)(const mlx_vector_array outputs) = NULL;
int (*mlx_jvp_ptr)(mlx_vector_array* res_0, mlx_vector_array* res_1, const mlx_closure fun, const mlx_vector_array primals, const mlx_vector_array tangents) = NULL;
int (*mlx_value_and_grad_ptr)(mlx_closure_value_and_grad* res, const mlx_closure fun, const int* argnums, size_t argnums_num) = NULL;
int (*mlx_vjp_ptr)(mlx_vector_array* res_0, mlx_vector_array* res_1, const mlx_closure fun, const mlx_vector_array primals, const mlx_vector_array cotangents) = NULL;
int (*mlx_detail_vmap_replace_ptr)(mlx_vector_array* res, const mlx_vector_array inputs, const mlx_vector_array s_inputs, const mlx_vector_array s_outputs, const int* in_axes, size_t in_axes_num, const int* out_axes, size_t out_axes_num) = NULL;
int (*mlx_detail_vmap_trace_ptr)(mlx_vector_array* res_0, mlx_vector_array* res_1, const mlx_closure fun, const mlx_vector_array inputs, const int* in_axes, size_t in_axes_num) = NULL;
mlx_vector_array (*mlx_vector_array_new_ptr)(void) = NULL;
int (*mlx_vector_array_set_ptr)(mlx_vector_array* vec, const mlx_vector_array src) = NULL;
int (*mlx_vector_array_free_ptr)(mlx_vector_array vec) = NULL;
mlx_vector_array (*mlx_vector_array_new_data_ptr)(const mlx_array* data, size_t size) = NULL;
mlx_vector_array (*mlx_vector_array_new_value_ptr)(const mlx_array val) = NULL;
int (*mlx_vector_array_set_data_ptr)(mlx_vector_array* vec, const mlx_array* data, size_t size) = NULL;
int (*mlx_vector_array_set_value_ptr)(mlx_vector_array* vec, const mlx_array val) = NULL;
int (*mlx_vector_array_append_data_ptr)(mlx_vector_array vec, const mlx_array* data, size_t size) = NULL;
int (*mlx_vector_array_append_value_ptr)(mlx_vector_array vec, const mlx_array val) = NULL;
size_t (*mlx_vector_array_size_ptr)(mlx_vector_array vec) = NULL;
int (*mlx_vector_array_get_ptr)(mlx_array* res, const mlx_vector_array vec, size_t idx) = NULL;
mlx_vector_vector_array (*mlx_vector_vector_array_new_ptr)(void) = NULL;
int (*mlx_vector_vector_array_set_ptr)(mlx_vector_vector_array* vec, const mlx_vector_vector_array src) = NULL;
int (*mlx_vector_vector_array_free_ptr)(mlx_vector_vector_array vec) = NULL;
mlx_vector_vector_array (*mlx_vector_vector_array_new_data_ptr)(const mlx_vector_array* data, size_t size) = NULL;
mlx_vector_vector_array (*mlx_vector_vector_array_new_value_ptr)(const mlx_vector_array val) = NULL;
int (*mlx_vector_vector_array_set_data_ptr)(mlx_vector_vector_array* vec, const mlx_vector_array* data, size_t size) = NULL;
int (*mlx_vector_vector_array_set_value_ptr)(mlx_vector_vector_array* vec, const mlx_vector_array val) = NULL;
int (*mlx_vector_vector_array_append_data_ptr)(mlx_vector_vector_array vec, const mlx_vector_array* data, size_t size) = NULL;
int (*mlx_vector_vector_array_append_value_ptr)(mlx_vector_vector_array vec, const mlx_vector_array val) = NULL;
size_t (*mlx_vector_vector_array_size_ptr)(mlx_vector_vector_array vec) = NULL;
int (*mlx_vector_vector_array_get_ptr)(mlx_vector_array* res, const mlx_vector_vector_array vec, size_t idx) = NULL;
mlx_vector_int (*mlx_vector_int_new_ptr)(void) = NULL;
int (*mlx_vector_int_set_ptr)(mlx_vector_int* vec, const mlx_vector_int src) = NULL;
int (*mlx_vector_int_free_ptr)(mlx_vector_int vec) = NULL;
mlx_vector_int (*mlx_vector_int_new_data_ptr)(int* data, size_t size) = NULL;
mlx_vector_int (*mlx_vector_int_new_value_ptr)(int val) = NULL;
int (*mlx_vector_int_set_data_ptr)(mlx_vector_int* vec, int* data, size_t size) = NULL;
int (*mlx_vector_int_set_value_ptr)(mlx_vector_int* vec, int val) = NULL;
int (*mlx_vector_int_append_data_ptr)(mlx_vector_int vec, int* data, size_t size) = NULL;
int (*mlx_vector_int_append_value_ptr)(mlx_vector_int vec, int val) = NULL;
size_t (*mlx_vector_int_size_ptr)(mlx_vector_int vec) = NULL;
int (*mlx_vector_int_get_ptr)(int* res, const mlx_vector_int vec, size_t idx) = NULL;
mlx_vector_string (*mlx_vector_string_new_ptr)(void) = NULL;
int (*mlx_vector_string_set_ptr)(mlx_vector_string* vec, const mlx_vector_string src) = NULL;
int (*mlx_vector_string_free_ptr)(mlx_vector_string vec) = NULL;
mlx_vector_string (*mlx_vector_string_new_data_ptr)(const char** data, size_t size) = NULL;
mlx_vector_string (*mlx_vector_string_new_value_ptr)(const char* val) = NULL;
int (*mlx_vector_string_set_data_ptr)(mlx_vector_string* vec, const char** data, size_t size) = NULL;
int (*mlx_vector_string_set_value_ptr)(mlx_vector_string* vec, const char* val) = NULL;
int (*mlx_vector_string_append_data_ptr)(mlx_vector_string vec, const char** data, size_t size) = NULL;
int (*mlx_vector_string_append_value_ptr)(mlx_vector_string vec, const char* val) = NULL;
size_t (*mlx_vector_string_size_ptr)(mlx_vector_string vec) = NULL;
int (*mlx_vector_string_get_ptr)(char** res, const mlx_vector_string vec, size_t idx) = NULL;
int (*mlx_version_ptr)(mlx_string* str_) = NULL;

// Initialize all function pointers via dlsym
int mlx_load_functions(void* handle) {
    if (handle == NULL) {
        fprintf(stderr, "MLX: Invalid library handle\n");
        return -1;
    }

    mlx_dtype_size_ptr = dlsym(handle, "mlx_dtype_size");
    if (mlx_dtype_size_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_dtype_size\n");
        return -1;
    }
    mlx_array_tostring_ptr = dlsym(handle, "mlx_array_tostring");
    if (mlx_array_tostring_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_tostring\n");
        return -1;
    }
    mlx_array_new_ptr = dlsym(handle, "mlx_array_new");
    if (mlx_array_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_new\n");
        return -1;
    }
    mlx_array_free_ptr = dlsym(handle, "mlx_array_free");
    if (mlx_array_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_free\n");
        return -1;
    }
    mlx_array_new_bool_ptr = dlsym(handle, "mlx_array_new_bool");
    if (mlx_array_new_bool_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_new_bool\n");
        return -1;
    }
    mlx_array_new_int_ptr = dlsym(handle, "mlx_array_new_int");
    if (mlx_array_new_int_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_new_int\n");
        return -1;
    }
    mlx_array_new_float32_ptr = dlsym(handle, "mlx_array_new_float32");
    if (mlx_array_new_float32_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_new_float32\n");
        return -1;
    }
    mlx_array_new_float_ptr = dlsym(handle, "mlx_array_new_float");
    if (mlx_array_new_float_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_new_float\n");
        return -1;
    }
    mlx_array_new_float64_ptr = dlsym(handle, "mlx_array_new_float64");
    if (mlx_array_new_float64_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_new_float64\n");
        return -1;
    }
    mlx_array_new_double_ptr = dlsym(handle, "mlx_array_new_double");
    if (mlx_array_new_double_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_new_double\n");
        return -1;
    }
    mlx_array_new_complex_ptr = dlsym(handle, "mlx_array_new_complex");
    if (mlx_array_new_complex_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_new_complex\n");
        return -1;
    }
    mlx_array_new_data_ptr = dlsym(handle, "mlx_array_new_data");
    if (mlx_array_new_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_new_data\n");
        return -1;
    }
    mlx_array_set_ptr = dlsym(handle, "mlx_array_set");
    if (mlx_array_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_set\n");
        return -1;
    }
    mlx_array_set_bool_ptr = dlsym(handle, "mlx_array_set_bool");
    if (mlx_array_set_bool_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_set_bool\n");
        return -1;
    }
    mlx_array_set_int_ptr = dlsym(handle, "mlx_array_set_int");
    if (mlx_array_set_int_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_set_int\n");
        return -1;
    }
    mlx_array_set_float32_ptr = dlsym(handle, "mlx_array_set_float32");
    if (mlx_array_set_float32_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_set_float32\n");
        return -1;
    }
    mlx_array_set_float_ptr = dlsym(handle, "mlx_array_set_float");
    if (mlx_array_set_float_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_set_float\n");
        return -1;
    }
    mlx_array_set_float64_ptr = dlsym(handle, "mlx_array_set_float64");
    if (mlx_array_set_float64_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_set_float64\n");
        return -1;
    }
    mlx_array_set_double_ptr = dlsym(handle, "mlx_array_set_double");
    if (mlx_array_set_double_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_set_double\n");
        return -1;
    }
    mlx_array_set_complex_ptr = dlsym(handle, "mlx_array_set_complex");
    if (mlx_array_set_complex_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_set_complex\n");
        return -1;
    }
    mlx_array_set_data_ptr = dlsym(handle, "mlx_array_set_data");
    if (mlx_array_set_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_set_data\n");
        return -1;
    }
    mlx_array_itemsize_ptr = dlsym(handle, "mlx_array_itemsize");
    if (mlx_array_itemsize_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_itemsize\n");
        return -1;
    }
    mlx_array_size_ptr = dlsym(handle, "mlx_array_size");
    if (mlx_array_size_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_size\n");
        return -1;
    }
    mlx_array_nbytes_ptr = dlsym(handle, "mlx_array_nbytes");
    if (mlx_array_nbytes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_nbytes\n");
        return -1;
    }
    mlx_array_ndim_ptr = dlsym(handle, "mlx_array_ndim");
    if (mlx_array_ndim_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_ndim\n");
        return -1;
    }
    mlx_array_shape_ptr = dlsym(handle, "mlx_array_shape");
    if (mlx_array_shape_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_shape\n");
        return -1;
    }
    mlx_array_strides_ptr = dlsym(handle, "mlx_array_strides");
    if (mlx_array_strides_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_strides\n");
        return -1;
    }
    mlx_array_dim_ptr = dlsym(handle, "mlx_array_dim");
    if (mlx_array_dim_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_dim\n");
        return -1;
    }
    mlx_array_dtype_ptr = dlsym(handle, "mlx_array_dtype");
    if (mlx_array_dtype_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_dtype\n");
        return -1;
    }
    mlx_array_eval_ptr = dlsym(handle, "mlx_array_eval");
    if (mlx_array_eval_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_eval\n");
        return -1;
    }
    mlx_array_item_bool_ptr = dlsym(handle, "mlx_array_item_bool");
    if (mlx_array_item_bool_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_bool\n");
        return -1;
    }
    mlx_array_item_uint8_ptr = dlsym(handle, "mlx_array_item_uint8");
    if (mlx_array_item_uint8_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_uint8\n");
        return -1;
    }
    mlx_array_item_uint16_ptr = dlsym(handle, "mlx_array_item_uint16");
    if (mlx_array_item_uint16_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_uint16\n");
        return -1;
    }
    mlx_array_item_uint32_ptr = dlsym(handle, "mlx_array_item_uint32");
    if (mlx_array_item_uint32_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_uint32\n");
        return -1;
    }
    mlx_array_item_uint64_ptr = dlsym(handle, "mlx_array_item_uint64");
    if (mlx_array_item_uint64_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_uint64\n");
        return -1;
    }
    mlx_array_item_int8_ptr = dlsym(handle, "mlx_array_item_int8");
    if (mlx_array_item_int8_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_int8\n");
        return -1;
    }
    mlx_array_item_int16_ptr = dlsym(handle, "mlx_array_item_int16");
    if (mlx_array_item_int16_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_int16\n");
        return -1;
    }
    mlx_array_item_int32_ptr = dlsym(handle, "mlx_array_item_int32");
    if (mlx_array_item_int32_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_int32\n");
        return -1;
    }
    mlx_array_item_int64_ptr = dlsym(handle, "mlx_array_item_int64");
    if (mlx_array_item_int64_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_int64\n");
        return -1;
    }
    mlx_array_item_float32_ptr = dlsym(handle, "mlx_array_item_float32");
    if (mlx_array_item_float32_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_float32\n");
        return -1;
    }
    mlx_array_item_float64_ptr = dlsym(handle, "mlx_array_item_float64");
    if (mlx_array_item_float64_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_float64\n");
        return -1;
    }
    mlx_array_item_complex64_ptr = dlsym(handle, "mlx_array_item_complex64");
    if (mlx_array_item_complex64_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_complex64\n");
        return -1;
    }
#if defined(__aarch64__) || defined(_M_ARM64)
    mlx_array_item_float16_ptr = dlsym(handle, "mlx_array_item_float16");
    if (mlx_array_item_float16_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_float16\n");
        return -1;
    }
#endif
#if defined(__aarch64__) || defined(_M_ARM64)
    mlx_array_item_bfloat16_ptr = dlsym(handle, "mlx_array_item_bfloat16");
    if (mlx_array_item_bfloat16_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_item_bfloat16\n");
        return -1;
    }
#endif
    mlx_array_data_bool_ptr = dlsym(handle, "mlx_array_data_bool");
    if (mlx_array_data_bool_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_bool\n");
        return -1;
    }
    mlx_array_data_uint8_ptr = dlsym(handle, "mlx_array_data_uint8");
    if (mlx_array_data_uint8_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_uint8\n");
        return -1;
    }
    mlx_array_data_uint16_ptr = dlsym(handle, "mlx_array_data_uint16");
    if (mlx_array_data_uint16_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_uint16\n");
        return -1;
    }
    mlx_array_data_uint32_ptr = dlsym(handle, "mlx_array_data_uint32");
    if (mlx_array_data_uint32_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_uint32\n");
        return -1;
    }
    mlx_array_data_uint64_ptr = dlsym(handle, "mlx_array_data_uint64");
    if (mlx_array_data_uint64_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_uint64\n");
        return -1;
    }
    mlx_array_data_int8_ptr = dlsym(handle, "mlx_array_data_int8");
    if (mlx_array_data_int8_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_int8\n");
        return -1;
    }
    mlx_array_data_int16_ptr = dlsym(handle, "mlx_array_data_int16");
    if (mlx_array_data_int16_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_int16\n");
        return -1;
    }
    mlx_array_data_int32_ptr = dlsym(handle, "mlx_array_data_int32");
    if (mlx_array_data_int32_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_int32\n");
        return -1;
    }
    mlx_array_data_int64_ptr = dlsym(handle, "mlx_array_data_int64");
    if (mlx_array_data_int64_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_int64\n");
        return -1;
    }
    mlx_array_data_float32_ptr = dlsym(handle, "mlx_array_data_float32");
    if (mlx_array_data_float32_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_float32\n");
        return -1;
    }
    mlx_array_data_float64_ptr = dlsym(handle, "mlx_array_data_float64");
    if (mlx_array_data_float64_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_float64\n");
        return -1;
    }
    mlx_array_data_complex64_ptr = dlsym(handle, "mlx_array_data_complex64");
    if (mlx_array_data_complex64_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_complex64\n");
        return -1;
    }
#if defined(__aarch64__) || defined(_M_ARM64)
    mlx_array_data_float16_ptr = dlsym(handle, "mlx_array_data_float16");
    if (mlx_array_data_float16_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_float16\n");
        return -1;
    }
#endif
#if defined(__aarch64__) || defined(_M_ARM64)
    mlx_array_data_bfloat16_ptr = dlsym(handle, "mlx_array_data_bfloat16");
    if (mlx_array_data_bfloat16_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_data_bfloat16\n");
        return -1;
    }
#endif
    _mlx_array_is_available_ptr = dlsym(handle, "_mlx_array_is_available");
    if (_mlx_array_is_available_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: _mlx_array_is_available\n");
        return -1;
    }
    _mlx_array_wait_ptr = dlsym(handle, "_mlx_array_wait");
    if (_mlx_array_wait_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: _mlx_array_wait\n");
        return -1;
    }
    _mlx_array_is_contiguous_ptr = dlsym(handle, "_mlx_array_is_contiguous");
    if (_mlx_array_is_contiguous_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: _mlx_array_is_contiguous\n");
        return -1;
    }
    _mlx_array_is_row_contiguous_ptr = dlsym(handle, "_mlx_array_is_row_contiguous");
    if (_mlx_array_is_row_contiguous_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: _mlx_array_is_row_contiguous\n");
        return -1;
    }
    _mlx_array_is_col_contiguous_ptr = dlsym(handle, "_mlx_array_is_col_contiguous");
    if (_mlx_array_is_col_contiguous_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: _mlx_array_is_col_contiguous\n");
        return -1;
    }
    mlx_closure_new_ptr = dlsym(handle, "mlx_closure_new");
    if (mlx_closure_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_new\n");
        return -1;
    }
    mlx_closure_free_ptr = dlsym(handle, "mlx_closure_free");
    if (mlx_closure_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_free\n");
        return -1;
    }
    mlx_closure_new_func_ptr = dlsym(handle, "mlx_closure_new_func");
    if (mlx_closure_new_func_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_new_func\n");
        return -1;
    }
    mlx_closure_new_func_payload_ptr = dlsym(handle, "mlx_closure_new_func_payload");
    if (mlx_closure_new_func_payload_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_new_func_payload\n");
        return -1;
    }
    mlx_closure_set_ptr = dlsym(handle, "mlx_closure_set");
    if (mlx_closure_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_set\n");
        return -1;
    }
    mlx_closure_apply_ptr = dlsym(handle, "mlx_closure_apply");
    if (mlx_closure_apply_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_apply\n");
        return -1;
    }
    mlx_closure_new_unary_ptr = dlsym(handle, "mlx_closure_new_unary");
    if (mlx_closure_new_unary_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_new_unary\n");
        return -1;
    }
    mlx_closure_kwargs_new_ptr = dlsym(handle, "mlx_closure_kwargs_new");
    if (mlx_closure_kwargs_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_kwargs_new\n");
        return -1;
    }
    mlx_closure_kwargs_free_ptr = dlsym(handle, "mlx_closure_kwargs_free");
    if (mlx_closure_kwargs_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_kwargs_free\n");
        return -1;
    }
    mlx_closure_kwargs_new_func_ptr = dlsym(handle, "mlx_closure_kwargs_new_func");
    if (mlx_closure_kwargs_new_func_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_kwargs_new_func\n");
        return -1;
    }
    mlx_closure_kwargs_new_func_payload_ptr = dlsym(handle, "mlx_closure_kwargs_new_func_payload");
    if (mlx_closure_kwargs_new_func_payload_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_kwargs_new_func_payload\n");
        return -1;
    }
    mlx_closure_kwargs_set_ptr = dlsym(handle, "mlx_closure_kwargs_set");
    if (mlx_closure_kwargs_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_kwargs_set\n");
        return -1;
    }
    mlx_closure_kwargs_apply_ptr = dlsym(handle, "mlx_closure_kwargs_apply");
    if (mlx_closure_kwargs_apply_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_kwargs_apply\n");
        return -1;
    }
    mlx_closure_value_and_grad_new_ptr = dlsym(handle, "mlx_closure_value_and_grad_new");
    if (mlx_closure_value_and_grad_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_value_and_grad_new\n");
        return -1;
    }
    mlx_closure_value_and_grad_free_ptr = dlsym(handle, "mlx_closure_value_and_grad_free");
    if (mlx_closure_value_and_grad_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_value_and_grad_free\n");
        return -1;
    }
    mlx_closure_value_and_grad_new_func_ptr = dlsym(handle, "mlx_closure_value_and_grad_new_func");
    if (mlx_closure_value_and_grad_new_func_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_value_and_grad_new_func\n");
        return -1;
    }
    mlx_closure_value_and_grad_new_func_payload_ptr = dlsym(handle, "mlx_closure_value_and_grad_new_func_payload");
    if (mlx_closure_value_and_grad_new_func_payload_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_value_and_grad_new_func_payload\n");
        return -1;
    }
    mlx_closure_value_and_grad_set_ptr = dlsym(handle, "mlx_closure_value_and_grad_set");
    if (mlx_closure_value_and_grad_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_value_and_grad_set\n");
        return -1;
    }
    mlx_closure_value_and_grad_apply_ptr = dlsym(handle, "mlx_closure_value_and_grad_apply");
    if (mlx_closure_value_and_grad_apply_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_value_and_grad_apply\n");
        return -1;
    }
    mlx_closure_custom_new_ptr = dlsym(handle, "mlx_closure_custom_new");
    if (mlx_closure_custom_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_new\n");
        return -1;
    }
    mlx_closure_custom_free_ptr = dlsym(handle, "mlx_closure_custom_free");
    if (mlx_closure_custom_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_free\n");
        return -1;
    }
    mlx_closure_custom_new_func_ptr = dlsym(handle, "mlx_closure_custom_new_func");
    if (mlx_closure_custom_new_func_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_new_func\n");
        return -1;
    }
    mlx_closure_custom_new_func_payload_ptr = dlsym(handle, "mlx_closure_custom_new_func_payload");
    if (mlx_closure_custom_new_func_payload_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_new_func_payload\n");
        return -1;
    }
    mlx_closure_custom_set_ptr = dlsym(handle, "mlx_closure_custom_set");
    if (mlx_closure_custom_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_set\n");
        return -1;
    }
    mlx_closure_custom_apply_ptr = dlsym(handle, "mlx_closure_custom_apply");
    if (mlx_closure_custom_apply_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_apply\n");
        return -1;
    }
    mlx_closure_custom_jvp_new_ptr = dlsym(handle, "mlx_closure_custom_jvp_new");
    if (mlx_closure_custom_jvp_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_jvp_new\n");
        return -1;
    }
    mlx_closure_custom_jvp_free_ptr = dlsym(handle, "mlx_closure_custom_jvp_free");
    if (mlx_closure_custom_jvp_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_jvp_free\n");
        return -1;
    }
    mlx_closure_custom_jvp_new_func_ptr = dlsym(handle, "mlx_closure_custom_jvp_new_func");
    if (mlx_closure_custom_jvp_new_func_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_jvp_new_func\n");
        return -1;
    }
    mlx_closure_custom_jvp_new_func_payload_ptr = dlsym(handle, "mlx_closure_custom_jvp_new_func_payload");
    if (mlx_closure_custom_jvp_new_func_payload_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_jvp_new_func_payload\n");
        return -1;
    }
    mlx_closure_custom_jvp_set_ptr = dlsym(handle, "mlx_closure_custom_jvp_set");
    if (mlx_closure_custom_jvp_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_jvp_set\n");
        return -1;
    }
    mlx_closure_custom_jvp_apply_ptr = dlsym(handle, "mlx_closure_custom_jvp_apply");
    if (mlx_closure_custom_jvp_apply_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_jvp_apply\n");
        return -1;
    }
    mlx_closure_custom_vmap_new_ptr = dlsym(handle, "mlx_closure_custom_vmap_new");
    if (mlx_closure_custom_vmap_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_vmap_new\n");
        return -1;
    }
    mlx_closure_custom_vmap_free_ptr = dlsym(handle, "mlx_closure_custom_vmap_free");
    if (mlx_closure_custom_vmap_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_vmap_free\n");
        return -1;
    }
    mlx_closure_custom_vmap_new_func_ptr = dlsym(handle, "mlx_closure_custom_vmap_new_func");
    if (mlx_closure_custom_vmap_new_func_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_vmap_new_func\n");
        return -1;
    }
    mlx_closure_custom_vmap_new_func_payload_ptr = dlsym(handle, "mlx_closure_custom_vmap_new_func_payload");
    if (mlx_closure_custom_vmap_new_func_payload_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_vmap_new_func_payload\n");
        return -1;
    }
    mlx_closure_custom_vmap_set_ptr = dlsym(handle, "mlx_closure_custom_vmap_set");
    if (mlx_closure_custom_vmap_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_vmap_set\n");
        return -1;
    }
    mlx_closure_custom_vmap_apply_ptr = dlsym(handle, "mlx_closure_custom_vmap_apply");
    if (mlx_closure_custom_vmap_apply_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_closure_custom_vmap_apply\n");
        return -1;
    }
    mlx_compile_ptr = dlsym(handle, "mlx_compile");
    if (mlx_compile_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_compile\n");
        return -1;
    }
    mlx_detail_compile_ptr = dlsym(handle, "mlx_detail_compile");
    if (mlx_detail_compile_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_detail_compile\n");
        return -1;
    }
    mlx_detail_compile_clear_cache_ptr = dlsym(handle, "mlx_detail_compile_clear_cache");
    if (mlx_detail_compile_clear_cache_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_detail_compile_clear_cache\n");
        return -1;
    }
    mlx_detail_compile_erase_ptr = dlsym(handle, "mlx_detail_compile_erase");
    if (mlx_detail_compile_erase_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_detail_compile_erase\n");
        return -1;
    }
    mlx_disable_compile_ptr = dlsym(handle, "mlx_disable_compile");
    if (mlx_disable_compile_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_disable_compile\n");
        return -1;
    }
    mlx_enable_compile_ptr = dlsym(handle, "mlx_enable_compile");
    if (mlx_enable_compile_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_enable_compile\n");
        return -1;
    }
    mlx_set_compile_mode_ptr = dlsym(handle, "mlx_set_compile_mode");
    if (mlx_set_compile_mode_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_set_compile_mode\n");
        return -1;
    }
    mlx_device_new_ptr = dlsym(handle, "mlx_device_new");
    if (mlx_device_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_device_new\n");
        return -1;
    }
    mlx_device_new_type_ptr = dlsym(handle, "mlx_device_new_type");
    if (mlx_device_new_type_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_device_new_type\n");
        return -1;
    }
    mlx_device_free_ptr = dlsym(handle, "mlx_device_free");
    if (mlx_device_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_device_free\n");
        return -1;
    }
    mlx_device_set_ptr = dlsym(handle, "mlx_device_set");
    if (mlx_device_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_device_set\n");
        return -1;
    }
    mlx_device_tostring_ptr = dlsym(handle, "mlx_device_tostring");
    if (mlx_device_tostring_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_device_tostring\n");
        return -1;
    }
    mlx_device_equal_ptr = dlsym(handle, "mlx_device_equal");
    if (mlx_device_equal_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_device_equal\n");
        return -1;
    }
    mlx_device_get_index_ptr = dlsym(handle, "mlx_device_get_index");
    if (mlx_device_get_index_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_device_get_index\n");
        return -1;
    }
    mlx_device_get_type_ptr = dlsym(handle, "mlx_device_get_type");
    if (mlx_device_get_type_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_device_get_type\n");
        return -1;
    }
    mlx_get_default_device_ptr = dlsym(handle, "mlx_get_default_device");
    if (mlx_get_default_device_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_get_default_device\n");
        return -1;
    }
    mlx_set_default_device_ptr = dlsym(handle, "mlx_set_default_device");
    if (mlx_set_default_device_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_set_default_device\n");
        return -1;
    }
    mlx_distributed_all_gather_ptr = dlsym(handle, "mlx_distributed_all_gather");
    if (mlx_distributed_all_gather_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_all_gather\n");
        return -1;
    }
    mlx_distributed_all_max_ptr = dlsym(handle, "mlx_distributed_all_max");
    if (mlx_distributed_all_max_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_all_max\n");
        return -1;
    }
    mlx_distributed_all_min_ptr = dlsym(handle, "mlx_distributed_all_min");
    if (mlx_distributed_all_min_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_all_min\n");
        return -1;
    }
    mlx_distributed_all_sum_ptr = dlsym(handle, "mlx_distributed_all_sum");
    if (mlx_distributed_all_sum_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_all_sum\n");
        return -1;
    }
    mlx_distributed_recv_ptr = dlsym(handle, "mlx_distributed_recv");
    if (mlx_distributed_recv_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_recv\n");
        return -1;
    }
    mlx_distributed_recv_like_ptr = dlsym(handle, "mlx_distributed_recv_like");
    if (mlx_distributed_recv_like_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_recv_like\n");
        return -1;
    }
    mlx_distributed_send_ptr = dlsym(handle, "mlx_distributed_send");
    if (mlx_distributed_send_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_send\n");
        return -1;
    }
    mlx_distributed_sum_scatter_ptr = dlsym(handle, "mlx_distributed_sum_scatter");
    if (mlx_distributed_sum_scatter_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_sum_scatter\n");
        return -1;
    }
    mlx_distributed_group_rank_ptr = dlsym(handle, "mlx_distributed_group_rank");
    if (mlx_distributed_group_rank_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_group_rank\n");
        return -1;
    }
    mlx_distributed_group_size_ptr = dlsym(handle, "mlx_distributed_group_size");
    if (mlx_distributed_group_size_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_group_size\n");
        return -1;
    }
    mlx_distributed_group_split_ptr = dlsym(handle, "mlx_distributed_group_split");
    if (mlx_distributed_group_split_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_group_split\n");
        return -1;
    }
    mlx_distributed_is_available_ptr = dlsym(handle, "mlx_distributed_is_available");
    if (mlx_distributed_is_available_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_is_available\n");
        return -1;
    }
    mlx_distributed_init_ptr = dlsym(handle, "mlx_distributed_init");
    if (mlx_distributed_init_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_distributed_init\n");
        return -1;
    }
    mlx_set_error_handler_ptr = dlsym(handle, "mlx_set_error_handler");
    if (mlx_set_error_handler_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_set_error_handler\n");
        return -1;
    }
    _mlx_error_ptr = dlsym(handle, "_mlx_error");
    if (_mlx_error_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: _mlx_error\n");
        return -1;
    }
    mlx_export_function_ptr = dlsym(handle, "mlx_export_function");
    if (mlx_export_function_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_export_function\n");
        return -1;
    }
    mlx_export_function_kwargs_ptr = dlsym(handle, "mlx_export_function_kwargs");
    if (mlx_export_function_kwargs_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_export_function_kwargs\n");
        return -1;
    }
    mlx_function_exporter_new_ptr = dlsym(handle, "mlx_function_exporter_new");
    if (mlx_function_exporter_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_function_exporter_new\n");
        return -1;
    }
    mlx_function_exporter_free_ptr = dlsym(handle, "mlx_function_exporter_free");
    if (mlx_function_exporter_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_function_exporter_free\n");
        return -1;
    }
    mlx_function_exporter_apply_ptr = dlsym(handle, "mlx_function_exporter_apply");
    if (mlx_function_exporter_apply_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_function_exporter_apply\n");
        return -1;
    }
    mlx_function_exporter_apply_kwargs_ptr = dlsym(handle, "mlx_function_exporter_apply_kwargs");
    if (mlx_function_exporter_apply_kwargs_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_function_exporter_apply_kwargs\n");
        return -1;
    }
    mlx_imported_function_new_ptr = dlsym(handle, "mlx_imported_function_new");
    if (mlx_imported_function_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_imported_function_new\n");
        return -1;
    }
    mlx_imported_function_free_ptr = dlsym(handle, "mlx_imported_function_free");
    if (mlx_imported_function_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_imported_function_free\n");
        return -1;
    }
    mlx_imported_function_apply_ptr = dlsym(handle, "mlx_imported_function_apply");
    if (mlx_imported_function_apply_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_imported_function_apply\n");
        return -1;
    }
    mlx_imported_function_apply_kwargs_ptr = dlsym(handle, "mlx_imported_function_apply_kwargs");
    if (mlx_imported_function_apply_kwargs_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_imported_function_apply_kwargs\n");
        return -1;
    }
    mlx_fast_cuda_kernel_config_new_ptr = dlsym(handle, "mlx_fast_cuda_kernel_config_new");
    if (mlx_fast_cuda_kernel_config_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_config_new\n");
        return -1;
    }
    mlx_fast_cuda_kernel_config_free_ptr = dlsym(handle, "mlx_fast_cuda_kernel_config_free");
    if (mlx_fast_cuda_kernel_config_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_config_free\n");
        return -1;
    }
    mlx_fast_cuda_kernel_config_add_output_arg_ptr = dlsym(handle, "mlx_fast_cuda_kernel_config_add_output_arg");
    if (mlx_fast_cuda_kernel_config_add_output_arg_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_config_add_output_arg\n");
        return -1;
    }
    mlx_fast_cuda_kernel_config_set_grid_ptr = dlsym(handle, "mlx_fast_cuda_kernel_config_set_grid");
    if (mlx_fast_cuda_kernel_config_set_grid_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_config_set_grid\n");
        return -1;
    }
    mlx_fast_cuda_kernel_config_set_thread_group_ptr = dlsym(handle, "mlx_fast_cuda_kernel_config_set_thread_group");
    if (mlx_fast_cuda_kernel_config_set_thread_group_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_config_set_thread_group\n");
        return -1;
    }
    mlx_fast_cuda_kernel_config_set_init_value_ptr = dlsym(handle, "mlx_fast_cuda_kernel_config_set_init_value");
    if (mlx_fast_cuda_kernel_config_set_init_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_config_set_init_value\n");
        return -1;
    }
    mlx_fast_cuda_kernel_config_set_verbose_ptr = dlsym(handle, "mlx_fast_cuda_kernel_config_set_verbose");
    if (mlx_fast_cuda_kernel_config_set_verbose_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_config_set_verbose\n");
        return -1;
    }
    mlx_fast_cuda_kernel_config_add_template_arg_dtype_ptr = dlsym(handle, "mlx_fast_cuda_kernel_config_add_template_arg_dtype");
    if (mlx_fast_cuda_kernel_config_add_template_arg_dtype_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_config_add_template_arg_dtype\n");
        return -1;
    }
    mlx_fast_cuda_kernel_config_add_template_arg_int_ptr = dlsym(handle, "mlx_fast_cuda_kernel_config_add_template_arg_int");
    if (mlx_fast_cuda_kernel_config_add_template_arg_int_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_config_add_template_arg_int\n");
        return -1;
    }
    mlx_fast_cuda_kernel_config_add_template_arg_bool_ptr = dlsym(handle, "mlx_fast_cuda_kernel_config_add_template_arg_bool");
    if (mlx_fast_cuda_kernel_config_add_template_arg_bool_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_config_add_template_arg_bool\n");
        return -1;
    }
    mlx_fast_cuda_kernel_new_ptr = dlsym(handle, "mlx_fast_cuda_kernel_new");
    if (mlx_fast_cuda_kernel_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_new\n");
        return -1;
    }
    mlx_fast_cuda_kernel_free_ptr = dlsym(handle, "mlx_fast_cuda_kernel_free");
    if (mlx_fast_cuda_kernel_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_free\n");
        return -1;
    }
    mlx_fast_cuda_kernel_apply_ptr = dlsym(handle, "mlx_fast_cuda_kernel_apply");
    if (mlx_fast_cuda_kernel_apply_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_cuda_kernel_apply\n");
        return -1;
    }
    mlx_fast_layer_norm_ptr = dlsym(handle, "mlx_fast_layer_norm");
    if (mlx_fast_layer_norm_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_layer_norm\n");
        return -1;
    }
    mlx_fast_metal_kernel_config_new_ptr = dlsym(handle, "mlx_fast_metal_kernel_config_new");
    if (mlx_fast_metal_kernel_config_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_config_new\n");
        return -1;
    }
    mlx_fast_metal_kernel_config_free_ptr = dlsym(handle, "mlx_fast_metal_kernel_config_free");
    if (mlx_fast_metal_kernel_config_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_config_free\n");
        return -1;
    }
    mlx_fast_metal_kernel_config_add_output_arg_ptr = dlsym(handle, "mlx_fast_metal_kernel_config_add_output_arg");
    if (mlx_fast_metal_kernel_config_add_output_arg_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_config_add_output_arg\n");
        return -1;
    }
    mlx_fast_metal_kernel_config_set_grid_ptr = dlsym(handle, "mlx_fast_metal_kernel_config_set_grid");
    if (mlx_fast_metal_kernel_config_set_grid_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_config_set_grid\n");
        return -1;
    }
    mlx_fast_metal_kernel_config_set_thread_group_ptr = dlsym(handle, "mlx_fast_metal_kernel_config_set_thread_group");
    if (mlx_fast_metal_kernel_config_set_thread_group_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_config_set_thread_group\n");
        return -1;
    }
    mlx_fast_metal_kernel_config_set_init_value_ptr = dlsym(handle, "mlx_fast_metal_kernel_config_set_init_value");
    if (mlx_fast_metal_kernel_config_set_init_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_config_set_init_value\n");
        return -1;
    }
    mlx_fast_metal_kernel_config_set_verbose_ptr = dlsym(handle, "mlx_fast_metal_kernel_config_set_verbose");
    if (mlx_fast_metal_kernel_config_set_verbose_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_config_set_verbose\n");
        return -1;
    }
    mlx_fast_metal_kernel_config_add_template_arg_dtype_ptr = dlsym(handle, "mlx_fast_metal_kernel_config_add_template_arg_dtype");
    if (mlx_fast_metal_kernel_config_add_template_arg_dtype_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_config_add_template_arg_dtype\n");
        return -1;
    }
    mlx_fast_metal_kernel_config_add_template_arg_int_ptr = dlsym(handle, "mlx_fast_metal_kernel_config_add_template_arg_int");
    if (mlx_fast_metal_kernel_config_add_template_arg_int_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_config_add_template_arg_int\n");
        return -1;
    }
    mlx_fast_metal_kernel_config_add_template_arg_bool_ptr = dlsym(handle, "mlx_fast_metal_kernel_config_add_template_arg_bool");
    if (mlx_fast_metal_kernel_config_add_template_arg_bool_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_config_add_template_arg_bool\n");
        return -1;
    }
    mlx_fast_metal_kernel_new_ptr = dlsym(handle, "mlx_fast_metal_kernel_new");
    if (mlx_fast_metal_kernel_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_new\n");
        return -1;
    }
    mlx_fast_metal_kernel_free_ptr = dlsym(handle, "mlx_fast_metal_kernel_free");
    if (mlx_fast_metal_kernel_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_free\n");
        return -1;
    }
    mlx_fast_metal_kernel_apply_ptr = dlsym(handle, "mlx_fast_metal_kernel_apply");
    if (mlx_fast_metal_kernel_apply_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_metal_kernel_apply\n");
        return -1;
    }
    mlx_fast_rms_norm_ptr = dlsym(handle, "mlx_fast_rms_norm");
    if (mlx_fast_rms_norm_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_rms_norm\n");
        return -1;
    }
    mlx_fast_rope_ptr = dlsym(handle, "mlx_fast_rope");
    if (mlx_fast_rope_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_rope\n");
        return -1;
    }
    mlx_fast_rope_dynamic_ptr = dlsym(handle, "mlx_fast_rope_dynamic");
    if (mlx_fast_rope_dynamic_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_rope_dynamic\n");
        return -1;
    }
    mlx_fast_scaled_dot_product_attention_ptr = dlsym(handle, "mlx_fast_scaled_dot_product_attention");
    if (mlx_fast_scaled_dot_product_attention_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fast_scaled_dot_product_attention\n");
        return -1;
    }
    mlx_fft_fft_ptr = dlsym(handle, "mlx_fft_fft");
    if (mlx_fft_fft_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_fft\n");
        return -1;
    }
    mlx_fft_fft2_ptr = dlsym(handle, "mlx_fft_fft2");
    if (mlx_fft_fft2_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_fft2\n");
        return -1;
    }
    mlx_fft_fftn_ptr = dlsym(handle, "mlx_fft_fftn");
    if (mlx_fft_fftn_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_fftn\n");
        return -1;
    }
    mlx_fft_fftshift_ptr = dlsym(handle, "mlx_fft_fftshift");
    if (mlx_fft_fftshift_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_fftshift\n");
        return -1;
    }
    mlx_fft_ifft_ptr = dlsym(handle, "mlx_fft_ifft");
    if (mlx_fft_ifft_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_ifft\n");
        return -1;
    }
    mlx_fft_ifft2_ptr = dlsym(handle, "mlx_fft_ifft2");
    if (mlx_fft_ifft2_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_ifft2\n");
        return -1;
    }
    mlx_fft_ifftn_ptr = dlsym(handle, "mlx_fft_ifftn");
    if (mlx_fft_ifftn_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_ifftn\n");
        return -1;
    }
    mlx_fft_ifftshift_ptr = dlsym(handle, "mlx_fft_ifftshift");
    if (mlx_fft_ifftshift_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_ifftshift\n");
        return -1;
    }
    mlx_fft_irfft_ptr = dlsym(handle, "mlx_fft_irfft");
    if (mlx_fft_irfft_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_irfft\n");
        return -1;
    }
    mlx_fft_irfft2_ptr = dlsym(handle, "mlx_fft_irfft2");
    if (mlx_fft_irfft2_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_irfft2\n");
        return -1;
    }
    mlx_fft_irfftn_ptr = dlsym(handle, "mlx_fft_irfftn");
    if (mlx_fft_irfftn_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_irfftn\n");
        return -1;
    }
    mlx_fft_rfft_ptr = dlsym(handle, "mlx_fft_rfft");
    if (mlx_fft_rfft_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_rfft\n");
        return -1;
    }
    mlx_fft_rfft2_ptr = dlsym(handle, "mlx_fft_rfft2");
    if (mlx_fft_rfft2_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_rfft2\n");
        return -1;
    }
    mlx_fft_rfftn_ptr = dlsym(handle, "mlx_fft_rfftn");
    if (mlx_fft_rfftn_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_fft_rfftn\n");
        return -1;
    }
    mlx_load_reader_ptr = dlsym(handle, "mlx_load_reader");
    if (mlx_load_reader_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_load_reader\n");
        return -1;
    }
    mlx_load_ptr = dlsym(handle, "mlx_load");
    if (mlx_load_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_load\n");
        return -1;
    }
    mlx_load_safetensors_reader_ptr = dlsym(handle, "mlx_load_safetensors_reader");
    if (mlx_load_safetensors_reader_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_load_safetensors_reader\n");
        return -1;
    }
    mlx_load_safetensors_ptr = dlsym(handle, "mlx_load_safetensors");
    if (mlx_load_safetensors_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_load_safetensors\n");
        return -1;
    }
    mlx_save_writer_ptr = dlsym(handle, "mlx_save_writer");
    if (mlx_save_writer_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_save_writer\n");
        return -1;
    }
    mlx_save_ptr = dlsym(handle, "mlx_save");
    if (mlx_save_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_save\n");
        return -1;
    }
    mlx_save_safetensors_writer_ptr = dlsym(handle, "mlx_save_safetensors_writer");
    if (mlx_save_safetensors_writer_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_save_safetensors_writer\n");
        return -1;
    }
    mlx_save_safetensors_ptr = dlsym(handle, "mlx_save_safetensors");
    if (mlx_save_safetensors_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_save_safetensors\n");
        return -1;
    }
    mlx_io_reader_new_ptr = dlsym(handle, "mlx_io_reader_new");
    if (mlx_io_reader_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_io_reader_new\n");
        return -1;
    }
    mlx_io_reader_descriptor_ptr = dlsym(handle, "mlx_io_reader_descriptor");
    if (mlx_io_reader_descriptor_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_io_reader_descriptor\n");
        return -1;
    }
    mlx_io_reader_tostring_ptr = dlsym(handle, "mlx_io_reader_tostring");
    if (mlx_io_reader_tostring_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_io_reader_tostring\n");
        return -1;
    }
    mlx_io_reader_free_ptr = dlsym(handle, "mlx_io_reader_free");
    if (mlx_io_reader_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_io_reader_free\n");
        return -1;
    }
    mlx_io_writer_new_ptr = dlsym(handle, "mlx_io_writer_new");
    if (mlx_io_writer_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_io_writer_new\n");
        return -1;
    }
    mlx_io_writer_descriptor_ptr = dlsym(handle, "mlx_io_writer_descriptor");
    if (mlx_io_writer_descriptor_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_io_writer_descriptor\n");
        return -1;
    }
    mlx_io_writer_tostring_ptr = dlsym(handle, "mlx_io_writer_tostring");
    if (mlx_io_writer_tostring_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_io_writer_tostring\n");
        return -1;
    }
    mlx_io_writer_free_ptr = dlsym(handle, "mlx_io_writer_free");
    if (mlx_io_writer_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_io_writer_free\n");
        return -1;
    }
    mlx_linalg_cholesky_ptr = dlsym(handle, "mlx_linalg_cholesky");
    if (mlx_linalg_cholesky_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_cholesky\n");
        return -1;
    }
    mlx_linalg_cholesky_inv_ptr = dlsym(handle, "mlx_linalg_cholesky_inv");
    if (mlx_linalg_cholesky_inv_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_cholesky_inv\n");
        return -1;
    }
    mlx_linalg_cross_ptr = dlsym(handle, "mlx_linalg_cross");
    if (mlx_linalg_cross_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_cross\n");
        return -1;
    }
    mlx_linalg_eig_ptr = dlsym(handle, "mlx_linalg_eig");
    if (mlx_linalg_eig_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_eig\n");
        return -1;
    }
    mlx_linalg_eigh_ptr = dlsym(handle, "mlx_linalg_eigh");
    if (mlx_linalg_eigh_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_eigh\n");
        return -1;
    }
    mlx_linalg_eigvals_ptr = dlsym(handle, "mlx_linalg_eigvals");
    if (mlx_linalg_eigvals_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_eigvals\n");
        return -1;
    }
    mlx_linalg_eigvalsh_ptr = dlsym(handle, "mlx_linalg_eigvalsh");
    if (mlx_linalg_eigvalsh_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_eigvalsh\n");
        return -1;
    }
    mlx_linalg_inv_ptr = dlsym(handle, "mlx_linalg_inv");
    if (mlx_linalg_inv_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_inv\n");
        return -1;
    }
    mlx_linalg_lu_ptr = dlsym(handle, "mlx_linalg_lu");
    if (mlx_linalg_lu_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_lu\n");
        return -1;
    }
    mlx_linalg_lu_factor_ptr = dlsym(handle, "mlx_linalg_lu_factor");
    if (mlx_linalg_lu_factor_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_lu_factor\n");
        return -1;
    }
    mlx_linalg_norm_ptr = dlsym(handle, "mlx_linalg_norm");
    if (mlx_linalg_norm_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_norm\n");
        return -1;
    }
    mlx_linalg_norm_matrix_ptr = dlsym(handle, "mlx_linalg_norm_matrix");
    if (mlx_linalg_norm_matrix_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_norm_matrix\n");
        return -1;
    }
    mlx_linalg_norm_l2_ptr = dlsym(handle, "mlx_linalg_norm_l2");
    if (mlx_linalg_norm_l2_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_norm_l2\n");
        return -1;
    }
    mlx_linalg_pinv_ptr = dlsym(handle, "mlx_linalg_pinv");
    if (mlx_linalg_pinv_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_pinv\n");
        return -1;
    }
    mlx_linalg_qr_ptr = dlsym(handle, "mlx_linalg_qr");
    if (mlx_linalg_qr_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_qr\n");
        return -1;
    }
    mlx_linalg_solve_ptr = dlsym(handle, "mlx_linalg_solve");
    if (mlx_linalg_solve_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_solve\n");
        return -1;
    }
    mlx_linalg_solve_triangular_ptr = dlsym(handle, "mlx_linalg_solve_triangular");
    if (mlx_linalg_solve_triangular_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_solve_triangular\n");
        return -1;
    }
    mlx_linalg_svd_ptr = dlsym(handle, "mlx_linalg_svd");
    if (mlx_linalg_svd_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_svd\n");
        return -1;
    }
    mlx_linalg_tri_inv_ptr = dlsym(handle, "mlx_linalg_tri_inv");
    if (mlx_linalg_tri_inv_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linalg_tri_inv\n");
        return -1;
    }
    mlx_map_string_to_array_new_ptr = dlsym(handle, "mlx_map_string_to_array_new");
    if (mlx_map_string_to_array_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_array_new\n");
        return -1;
    }
    mlx_map_string_to_array_set_ptr = dlsym(handle, "mlx_map_string_to_array_set");
    if (mlx_map_string_to_array_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_array_set\n");
        return -1;
    }
    mlx_map_string_to_array_free_ptr = dlsym(handle, "mlx_map_string_to_array_free");
    if (mlx_map_string_to_array_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_array_free\n");
        return -1;
    }
    mlx_map_string_to_array_insert_ptr = dlsym(handle, "mlx_map_string_to_array_insert");
    if (mlx_map_string_to_array_insert_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_array_insert\n");
        return -1;
    }
    mlx_map_string_to_array_get_ptr = dlsym(handle, "mlx_map_string_to_array_get");
    if (mlx_map_string_to_array_get_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_array_get\n");
        return -1;
    }
    mlx_map_string_to_array_iterator_new_ptr = dlsym(handle, "mlx_map_string_to_array_iterator_new");
    if (mlx_map_string_to_array_iterator_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_array_iterator_new\n");
        return -1;
    }
    mlx_map_string_to_array_iterator_free_ptr = dlsym(handle, "mlx_map_string_to_array_iterator_free");
    if (mlx_map_string_to_array_iterator_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_array_iterator_free\n");
        return -1;
    }
    mlx_map_string_to_array_iterator_next_ptr = dlsym(handle, "mlx_map_string_to_array_iterator_next");
    if (mlx_map_string_to_array_iterator_next_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_array_iterator_next\n");
        return -1;
    }
    mlx_map_string_to_string_new_ptr = dlsym(handle, "mlx_map_string_to_string_new");
    if (mlx_map_string_to_string_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_string_new\n");
        return -1;
    }
    mlx_map_string_to_string_set_ptr = dlsym(handle, "mlx_map_string_to_string_set");
    if (mlx_map_string_to_string_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_string_set\n");
        return -1;
    }
    mlx_map_string_to_string_free_ptr = dlsym(handle, "mlx_map_string_to_string_free");
    if (mlx_map_string_to_string_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_string_free\n");
        return -1;
    }
    mlx_map_string_to_string_insert_ptr = dlsym(handle, "mlx_map_string_to_string_insert");
    if (mlx_map_string_to_string_insert_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_string_insert\n");
        return -1;
    }
    mlx_map_string_to_string_get_ptr = dlsym(handle, "mlx_map_string_to_string_get");
    if (mlx_map_string_to_string_get_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_string_get\n");
        return -1;
    }
    mlx_map_string_to_string_iterator_new_ptr = dlsym(handle, "mlx_map_string_to_string_iterator_new");
    if (mlx_map_string_to_string_iterator_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_string_iterator_new\n");
        return -1;
    }
    mlx_map_string_to_string_iterator_free_ptr = dlsym(handle, "mlx_map_string_to_string_iterator_free");
    if (mlx_map_string_to_string_iterator_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_string_iterator_free\n");
        return -1;
    }
    mlx_map_string_to_string_iterator_next_ptr = dlsym(handle, "mlx_map_string_to_string_iterator_next");
    if (mlx_map_string_to_string_iterator_next_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_map_string_to_string_iterator_next\n");
        return -1;
    }
    mlx_clear_cache_ptr = dlsym(handle, "mlx_clear_cache");
    if (mlx_clear_cache_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_clear_cache\n");
        return -1;
    }
    mlx_get_active_memory_ptr = dlsym(handle, "mlx_get_active_memory");
    if (mlx_get_active_memory_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_get_active_memory\n");
        return -1;
    }
    mlx_get_cache_memory_ptr = dlsym(handle, "mlx_get_cache_memory");
    if (mlx_get_cache_memory_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_get_cache_memory\n");
        return -1;
    }
    mlx_get_memory_limit_ptr = dlsym(handle, "mlx_get_memory_limit");
    if (mlx_get_memory_limit_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_get_memory_limit\n");
        return -1;
    }
    mlx_get_peak_memory_ptr = dlsym(handle, "mlx_get_peak_memory");
    if (mlx_get_peak_memory_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_get_peak_memory\n");
        return -1;
    }
    mlx_reset_peak_memory_ptr = dlsym(handle, "mlx_reset_peak_memory");
    if (mlx_reset_peak_memory_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_reset_peak_memory\n");
        return -1;
    }
    mlx_set_cache_limit_ptr = dlsym(handle, "mlx_set_cache_limit");
    if (mlx_set_cache_limit_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_set_cache_limit\n");
        return -1;
    }
    mlx_set_memory_limit_ptr = dlsym(handle, "mlx_set_memory_limit");
    if (mlx_set_memory_limit_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_set_memory_limit\n");
        return -1;
    }
    mlx_set_wired_limit_ptr = dlsym(handle, "mlx_set_wired_limit");
    if (mlx_set_wired_limit_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_set_wired_limit\n");
        return -1;
    }
    mlx_metal_device_info_ptr = dlsym(handle, "mlx_metal_device_info");
    if (mlx_metal_device_info_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_metal_device_info\n");
        return -1;
    }
    mlx_metal_is_available_ptr = dlsym(handle, "mlx_metal_is_available");
    if (mlx_metal_is_available_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_metal_is_available\n");
        return -1;
    }
    mlx_metal_start_capture_ptr = dlsym(handle, "mlx_metal_start_capture");
    if (mlx_metal_start_capture_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_metal_start_capture\n");
        return -1;
    }
    mlx_metal_stop_capture_ptr = dlsym(handle, "mlx_metal_stop_capture");
    if (mlx_metal_stop_capture_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_metal_stop_capture\n");
        return -1;
    }
    mlx_abs_ptr = dlsym(handle, "mlx_abs");
    if (mlx_abs_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_abs\n");
        return -1;
    }
    mlx_add_ptr = dlsym(handle, "mlx_add");
    if (mlx_add_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_add\n");
        return -1;
    }
    mlx_addmm_ptr = dlsym(handle, "mlx_addmm");
    if (mlx_addmm_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_addmm\n");
        return -1;
    }
    mlx_all_axes_ptr = dlsym(handle, "mlx_all_axes");
    if (mlx_all_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_all_axes\n");
        return -1;
    }
    mlx_all_axis_ptr = dlsym(handle, "mlx_all_axis");
    if (mlx_all_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_all_axis\n");
        return -1;
    }
    mlx_all_ptr = dlsym(handle, "mlx_all");
    if (mlx_all_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_all\n");
        return -1;
    }
    mlx_allclose_ptr = dlsym(handle, "mlx_allclose");
    if (mlx_allclose_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_allclose\n");
        return -1;
    }
    mlx_any_axes_ptr = dlsym(handle, "mlx_any_axes");
    if (mlx_any_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_any_axes\n");
        return -1;
    }
    mlx_any_axis_ptr = dlsym(handle, "mlx_any_axis");
    if (mlx_any_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_any_axis\n");
        return -1;
    }
    mlx_any_ptr = dlsym(handle, "mlx_any");
    if (mlx_any_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_any\n");
        return -1;
    }
    mlx_arange_ptr = dlsym(handle, "mlx_arange");
    if (mlx_arange_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_arange\n");
        return -1;
    }
    mlx_arccos_ptr = dlsym(handle, "mlx_arccos");
    if (mlx_arccos_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_arccos\n");
        return -1;
    }
    mlx_arccosh_ptr = dlsym(handle, "mlx_arccosh");
    if (mlx_arccosh_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_arccosh\n");
        return -1;
    }
    mlx_arcsin_ptr = dlsym(handle, "mlx_arcsin");
    if (mlx_arcsin_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_arcsin\n");
        return -1;
    }
    mlx_arcsinh_ptr = dlsym(handle, "mlx_arcsinh");
    if (mlx_arcsinh_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_arcsinh\n");
        return -1;
    }
    mlx_arctan_ptr = dlsym(handle, "mlx_arctan");
    if (mlx_arctan_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_arctan\n");
        return -1;
    }
    mlx_arctan2_ptr = dlsym(handle, "mlx_arctan2");
    if (mlx_arctan2_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_arctan2\n");
        return -1;
    }
    mlx_arctanh_ptr = dlsym(handle, "mlx_arctanh");
    if (mlx_arctanh_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_arctanh\n");
        return -1;
    }
    mlx_argmax_axis_ptr = dlsym(handle, "mlx_argmax_axis");
    if (mlx_argmax_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_argmax_axis\n");
        return -1;
    }
    mlx_argmax_ptr = dlsym(handle, "mlx_argmax");
    if (mlx_argmax_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_argmax\n");
        return -1;
    }
    mlx_argmin_axis_ptr = dlsym(handle, "mlx_argmin_axis");
    if (mlx_argmin_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_argmin_axis\n");
        return -1;
    }
    mlx_argmin_ptr = dlsym(handle, "mlx_argmin");
    if (mlx_argmin_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_argmin\n");
        return -1;
    }
    mlx_argpartition_axis_ptr = dlsym(handle, "mlx_argpartition_axis");
    if (mlx_argpartition_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_argpartition_axis\n");
        return -1;
    }
    mlx_argpartition_ptr = dlsym(handle, "mlx_argpartition");
    if (mlx_argpartition_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_argpartition\n");
        return -1;
    }
    mlx_argsort_axis_ptr = dlsym(handle, "mlx_argsort_axis");
    if (mlx_argsort_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_argsort_axis\n");
        return -1;
    }
    mlx_argsort_ptr = dlsym(handle, "mlx_argsort");
    if (mlx_argsort_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_argsort\n");
        return -1;
    }
    mlx_array_equal_ptr = dlsym(handle, "mlx_array_equal");
    if (mlx_array_equal_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_array_equal\n");
        return -1;
    }
    mlx_as_strided_ptr = dlsym(handle, "mlx_as_strided");
    if (mlx_as_strided_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_as_strided\n");
        return -1;
    }
    mlx_astype_ptr = dlsym(handle, "mlx_astype");
    if (mlx_astype_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_astype\n");
        return -1;
    }
    mlx_atleast_1d_ptr = dlsym(handle, "mlx_atleast_1d");
    if (mlx_atleast_1d_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_atleast_1d\n");
        return -1;
    }
    mlx_atleast_2d_ptr = dlsym(handle, "mlx_atleast_2d");
    if (mlx_atleast_2d_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_atleast_2d\n");
        return -1;
    }
    mlx_atleast_3d_ptr = dlsym(handle, "mlx_atleast_3d");
    if (mlx_atleast_3d_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_atleast_3d\n");
        return -1;
    }
    mlx_bitwise_and_ptr = dlsym(handle, "mlx_bitwise_and");
    if (mlx_bitwise_and_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_bitwise_and\n");
        return -1;
    }
    mlx_bitwise_invert_ptr = dlsym(handle, "mlx_bitwise_invert");
    if (mlx_bitwise_invert_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_bitwise_invert\n");
        return -1;
    }
    mlx_bitwise_or_ptr = dlsym(handle, "mlx_bitwise_or");
    if (mlx_bitwise_or_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_bitwise_or\n");
        return -1;
    }
    mlx_bitwise_xor_ptr = dlsym(handle, "mlx_bitwise_xor");
    if (mlx_bitwise_xor_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_bitwise_xor\n");
        return -1;
    }
    mlx_block_masked_mm_ptr = dlsym(handle, "mlx_block_masked_mm");
    if (mlx_block_masked_mm_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_block_masked_mm\n");
        return -1;
    }
    mlx_broadcast_arrays_ptr = dlsym(handle, "mlx_broadcast_arrays");
    if (mlx_broadcast_arrays_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_broadcast_arrays\n");
        return -1;
    }
    mlx_broadcast_to_ptr = dlsym(handle, "mlx_broadcast_to");
    if (mlx_broadcast_to_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_broadcast_to\n");
        return -1;
    }
    mlx_ceil_ptr = dlsym(handle, "mlx_ceil");
    if (mlx_ceil_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_ceil\n");
        return -1;
    }
    mlx_clip_ptr = dlsym(handle, "mlx_clip");
    if (mlx_clip_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_clip\n");
        return -1;
    }
    mlx_concatenate_axis_ptr = dlsym(handle, "mlx_concatenate_axis");
    if (mlx_concatenate_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_concatenate_axis\n");
        return -1;
    }
    mlx_concatenate_ptr = dlsym(handle, "mlx_concatenate");
    if (mlx_concatenate_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_concatenate\n");
        return -1;
    }
    mlx_conjugate_ptr = dlsym(handle, "mlx_conjugate");
    if (mlx_conjugate_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_conjugate\n");
        return -1;
    }
    mlx_contiguous_ptr = dlsym(handle, "mlx_contiguous");
    if (mlx_contiguous_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_contiguous\n");
        return -1;
    }
    mlx_conv1d_ptr = dlsym(handle, "mlx_conv1d");
    if (mlx_conv1d_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_conv1d\n");
        return -1;
    }
    mlx_conv2d_ptr = dlsym(handle, "mlx_conv2d");
    if (mlx_conv2d_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_conv2d\n");
        return -1;
    }
    mlx_conv3d_ptr = dlsym(handle, "mlx_conv3d");
    if (mlx_conv3d_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_conv3d\n");
        return -1;
    }
    mlx_conv_general_ptr = dlsym(handle, "mlx_conv_general");
    if (mlx_conv_general_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_conv_general\n");
        return -1;
    }
    mlx_conv_transpose1d_ptr = dlsym(handle, "mlx_conv_transpose1d");
    if (mlx_conv_transpose1d_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_conv_transpose1d\n");
        return -1;
    }
    mlx_conv_transpose2d_ptr = dlsym(handle, "mlx_conv_transpose2d");
    if (mlx_conv_transpose2d_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_conv_transpose2d\n");
        return -1;
    }
    mlx_conv_transpose3d_ptr = dlsym(handle, "mlx_conv_transpose3d");
    if (mlx_conv_transpose3d_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_conv_transpose3d\n");
        return -1;
    }
    mlx_copy_ptr = dlsym(handle, "mlx_copy");
    if (mlx_copy_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_copy\n");
        return -1;
    }
    mlx_cos_ptr = dlsym(handle, "mlx_cos");
    if (mlx_cos_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_cos\n");
        return -1;
    }
    mlx_cosh_ptr = dlsym(handle, "mlx_cosh");
    if (mlx_cosh_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_cosh\n");
        return -1;
    }
    mlx_cummax_ptr = dlsym(handle, "mlx_cummax");
    if (mlx_cummax_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_cummax\n");
        return -1;
    }
    mlx_cummin_ptr = dlsym(handle, "mlx_cummin");
    if (mlx_cummin_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_cummin\n");
        return -1;
    }
    mlx_cumprod_ptr = dlsym(handle, "mlx_cumprod");
    if (mlx_cumprod_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_cumprod\n");
        return -1;
    }
    mlx_cumsum_ptr = dlsym(handle, "mlx_cumsum");
    if (mlx_cumsum_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_cumsum\n");
        return -1;
    }
    mlx_degrees_ptr = dlsym(handle, "mlx_degrees");
    if (mlx_degrees_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_degrees\n");
        return -1;
    }
    mlx_depends_ptr = dlsym(handle, "mlx_depends");
    if (mlx_depends_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_depends\n");
        return -1;
    }
    mlx_dequantize_ptr = dlsym(handle, "mlx_dequantize");
    if (mlx_dequantize_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_dequantize\n");
        return -1;
    }
    mlx_diag_ptr = dlsym(handle, "mlx_diag");
    if (mlx_diag_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_diag\n");
        return -1;
    }
    mlx_diagonal_ptr = dlsym(handle, "mlx_diagonal");
    if (mlx_diagonal_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_diagonal\n");
        return -1;
    }
    mlx_divide_ptr = dlsym(handle, "mlx_divide");
    if (mlx_divide_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_divide\n");
        return -1;
    }
    mlx_divmod_ptr = dlsym(handle, "mlx_divmod");
    if (mlx_divmod_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_divmod\n");
        return -1;
    }
    mlx_einsum_ptr = dlsym(handle, "mlx_einsum");
    if (mlx_einsum_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_einsum\n");
        return -1;
    }
    mlx_equal_ptr = dlsym(handle, "mlx_equal");
    if (mlx_equal_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_equal\n");
        return -1;
    }
    mlx_erf_ptr = dlsym(handle, "mlx_erf");
    if (mlx_erf_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_erf\n");
        return -1;
    }
    mlx_erfinv_ptr = dlsym(handle, "mlx_erfinv");
    if (mlx_erfinv_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_erfinv\n");
        return -1;
    }
    mlx_exp_ptr = dlsym(handle, "mlx_exp");
    if (mlx_exp_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_exp\n");
        return -1;
    }
    mlx_expand_dims_axes_ptr = dlsym(handle, "mlx_expand_dims_axes");
    if (mlx_expand_dims_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_expand_dims_axes\n");
        return -1;
    }
    mlx_expand_dims_ptr = dlsym(handle, "mlx_expand_dims");
    if (mlx_expand_dims_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_expand_dims\n");
        return -1;
    }
    mlx_expm1_ptr = dlsym(handle, "mlx_expm1");
    if (mlx_expm1_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_expm1\n");
        return -1;
    }
    mlx_eye_ptr = dlsym(handle, "mlx_eye");
    if (mlx_eye_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_eye\n");
        return -1;
    }
    mlx_flatten_ptr = dlsym(handle, "mlx_flatten");
    if (mlx_flatten_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_flatten\n");
        return -1;
    }
    mlx_floor_ptr = dlsym(handle, "mlx_floor");
    if (mlx_floor_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_floor\n");
        return -1;
    }
    mlx_floor_divide_ptr = dlsym(handle, "mlx_floor_divide");
    if (mlx_floor_divide_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_floor_divide\n");
        return -1;
    }
    mlx_from_fp8_ptr = dlsym(handle, "mlx_from_fp8");
    if (mlx_from_fp8_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_from_fp8\n");
        return -1;
    }
    mlx_full_ptr = dlsym(handle, "mlx_full");
    if (mlx_full_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_full\n");
        return -1;
    }
    mlx_full_like_ptr = dlsym(handle, "mlx_full_like");
    if (mlx_full_like_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_full_like\n");
        return -1;
    }
    mlx_gather_ptr = dlsym(handle, "mlx_gather");
    if (mlx_gather_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_gather\n");
        return -1;
    }
    mlx_gather_single_ptr = dlsym(handle, "mlx_gather_single");
    if (mlx_gather_single_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_gather_single\n");
        return -1;
    }
    mlx_gather_mm_ptr = dlsym(handle, "mlx_gather_mm");
    if (mlx_gather_mm_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_gather_mm\n");
        return -1;
    }
    mlx_gather_qmm_ptr = dlsym(handle, "mlx_gather_qmm");
    if (mlx_gather_qmm_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_gather_qmm\n");
        return -1;
    }
    mlx_greater_ptr = dlsym(handle, "mlx_greater");
    if (mlx_greater_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_greater\n");
        return -1;
    }
    mlx_greater_equal_ptr = dlsym(handle, "mlx_greater_equal");
    if (mlx_greater_equal_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_greater_equal\n");
        return -1;
    }
    mlx_hadamard_transform_ptr = dlsym(handle, "mlx_hadamard_transform");
    if (mlx_hadamard_transform_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_hadamard_transform\n");
        return -1;
    }
    mlx_identity_ptr = dlsym(handle, "mlx_identity");
    if (mlx_identity_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_identity\n");
        return -1;
    }
    mlx_imag_ptr = dlsym(handle, "mlx_imag");
    if (mlx_imag_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_imag\n");
        return -1;
    }
    mlx_inner_ptr = dlsym(handle, "mlx_inner");
    if (mlx_inner_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_inner\n");
        return -1;
    }
    mlx_isclose_ptr = dlsym(handle, "mlx_isclose");
    if (mlx_isclose_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_isclose\n");
        return -1;
    }
    mlx_isfinite_ptr = dlsym(handle, "mlx_isfinite");
    if (mlx_isfinite_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_isfinite\n");
        return -1;
    }
    mlx_isinf_ptr = dlsym(handle, "mlx_isinf");
    if (mlx_isinf_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_isinf\n");
        return -1;
    }
    mlx_isnan_ptr = dlsym(handle, "mlx_isnan");
    if (mlx_isnan_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_isnan\n");
        return -1;
    }
    mlx_isneginf_ptr = dlsym(handle, "mlx_isneginf");
    if (mlx_isneginf_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_isneginf\n");
        return -1;
    }
    mlx_isposinf_ptr = dlsym(handle, "mlx_isposinf");
    if (mlx_isposinf_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_isposinf\n");
        return -1;
    }
    mlx_kron_ptr = dlsym(handle, "mlx_kron");
    if (mlx_kron_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_kron\n");
        return -1;
    }
    mlx_left_shift_ptr = dlsym(handle, "mlx_left_shift");
    if (mlx_left_shift_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_left_shift\n");
        return -1;
    }
    mlx_less_ptr = dlsym(handle, "mlx_less");
    if (mlx_less_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_less\n");
        return -1;
    }
    mlx_less_equal_ptr = dlsym(handle, "mlx_less_equal");
    if (mlx_less_equal_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_less_equal\n");
        return -1;
    }
    mlx_linspace_ptr = dlsym(handle, "mlx_linspace");
    if (mlx_linspace_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_linspace\n");
        return -1;
    }
    mlx_log_ptr = dlsym(handle, "mlx_log");
    if (mlx_log_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_log\n");
        return -1;
    }
    mlx_log10_ptr = dlsym(handle, "mlx_log10");
    if (mlx_log10_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_log10\n");
        return -1;
    }
    mlx_log1p_ptr = dlsym(handle, "mlx_log1p");
    if (mlx_log1p_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_log1p\n");
        return -1;
    }
    mlx_log2_ptr = dlsym(handle, "mlx_log2");
    if (mlx_log2_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_log2\n");
        return -1;
    }
    mlx_logaddexp_ptr = dlsym(handle, "mlx_logaddexp");
    if (mlx_logaddexp_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_logaddexp\n");
        return -1;
    }
    mlx_logcumsumexp_ptr = dlsym(handle, "mlx_logcumsumexp");
    if (mlx_logcumsumexp_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_logcumsumexp\n");
        return -1;
    }
    mlx_logical_and_ptr = dlsym(handle, "mlx_logical_and");
    if (mlx_logical_and_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_logical_and\n");
        return -1;
    }
    mlx_logical_not_ptr = dlsym(handle, "mlx_logical_not");
    if (mlx_logical_not_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_logical_not\n");
        return -1;
    }
    mlx_logical_or_ptr = dlsym(handle, "mlx_logical_or");
    if (mlx_logical_or_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_logical_or\n");
        return -1;
    }
    mlx_logsumexp_axes_ptr = dlsym(handle, "mlx_logsumexp_axes");
    if (mlx_logsumexp_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_logsumexp_axes\n");
        return -1;
    }
    mlx_logsumexp_axis_ptr = dlsym(handle, "mlx_logsumexp_axis");
    if (mlx_logsumexp_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_logsumexp_axis\n");
        return -1;
    }
    mlx_logsumexp_ptr = dlsym(handle, "mlx_logsumexp");
    if (mlx_logsumexp_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_logsumexp\n");
        return -1;
    }
    mlx_masked_scatter_ptr = dlsym(handle, "mlx_masked_scatter");
    if (mlx_masked_scatter_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_masked_scatter\n");
        return -1;
    }
    mlx_matmul_ptr = dlsym(handle, "mlx_matmul");
    if (mlx_matmul_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_matmul\n");
        return -1;
    }
    mlx_max_axes_ptr = dlsym(handle, "mlx_max_axes");
    if (mlx_max_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_max_axes\n");
        return -1;
    }
    mlx_max_axis_ptr = dlsym(handle, "mlx_max_axis");
    if (mlx_max_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_max_axis\n");
        return -1;
    }
    mlx_max_ptr = dlsym(handle, "mlx_max");
    if (mlx_max_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_max\n");
        return -1;
    }
    mlx_maximum_ptr = dlsym(handle, "mlx_maximum");
    if (mlx_maximum_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_maximum\n");
        return -1;
    }
    mlx_mean_axes_ptr = dlsym(handle, "mlx_mean_axes");
    if (mlx_mean_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_mean_axes\n");
        return -1;
    }
    mlx_mean_axis_ptr = dlsym(handle, "mlx_mean_axis");
    if (mlx_mean_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_mean_axis\n");
        return -1;
    }
    mlx_mean_ptr = dlsym(handle, "mlx_mean");
    if (mlx_mean_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_mean\n");
        return -1;
    }
    mlx_median_ptr = dlsym(handle, "mlx_median");
    if (mlx_median_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_median\n");
        return -1;
    }
    mlx_meshgrid_ptr = dlsym(handle, "mlx_meshgrid");
    if (mlx_meshgrid_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_meshgrid\n");
        return -1;
    }
    mlx_min_axes_ptr = dlsym(handle, "mlx_min_axes");
    if (mlx_min_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_min_axes\n");
        return -1;
    }
    mlx_min_axis_ptr = dlsym(handle, "mlx_min_axis");
    if (mlx_min_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_min_axis\n");
        return -1;
    }
    mlx_min_ptr = dlsym(handle, "mlx_min");
    if (mlx_min_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_min\n");
        return -1;
    }
    mlx_minimum_ptr = dlsym(handle, "mlx_minimum");
    if (mlx_minimum_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_minimum\n");
        return -1;
    }
    mlx_moveaxis_ptr = dlsym(handle, "mlx_moveaxis");
    if (mlx_moveaxis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_moveaxis\n");
        return -1;
    }
    mlx_multiply_ptr = dlsym(handle, "mlx_multiply");
    if (mlx_multiply_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_multiply\n");
        return -1;
    }
    mlx_nan_to_num_ptr = dlsym(handle, "mlx_nan_to_num");
    if (mlx_nan_to_num_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_nan_to_num\n");
        return -1;
    }
    mlx_negative_ptr = dlsym(handle, "mlx_negative");
    if (mlx_negative_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_negative\n");
        return -1;
    }
    mlx_not_equal_ptr = dlsym(handle, "mlx_not_equal");
    if (mlx_not_equal_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_not_equal\n");
        return -1;
    }
    mlx_number_of_elements_ptr = dlsym(handle, "mlx_number_of_elements");
    if (mlx_number_of_elements_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_number_of_elements\n");
        return -1;
    }
    mlx_ones_ptr = dlsym(handle, "mlx_ones");
    if (mlx_ones_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_ones\n");
        return -1;
    }
    mlx_ones_like_ptr = dlsym(handle, "mlx_ones_like");
    if (mlx_ones_like_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_ones_like\n");
        return -1;
    }
    mlx_outer_ptr = dlsym(handle, "mlx_outer");
    if (mlx_outer_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_outer\n");
        return -1;
    }
    mlx_pad_ptr = dlsym(handle, "mlx_pad");
    if (mlx_pad_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_pad\n");
        return -1;
    }
    mlx_pad_symmetric_ptr = dlsym(handle, "mlx_pad_symmetric");
    if (mlx_pad_symmetric_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_pad_symmetric\n");
        return -1;
    }
    mlx_partition_axis_ptr = dlsym(handle, "mlx_partition_axis");
    if (mlx_partition_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_partition_axis\n");
        return -1;
    }
    mlx_partition_ptr = dlsym(handle, "mlx_partition");
    if (mlx_partition_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_partition\n");
        return -1;
    }
    mlx_power_ptr = dlsym(handle, "mlx_power");
    if (mlx_power_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_power\n");
        return -1;
    }
    mlx_prod_axes_ptr = dlsym(handle, "mlx_prod_axes");
    if (mlx_prod_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_prod_axes\n");
        return -1;
    }
    mlx_prod_axis_ptr = dlsym(handle, "mlx_prod_axis");
    if (mlx_prod_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_prod_axis\n");
        return -1;
    }
    mlx_prod_ptr = dlsym(handle, "mlx_prod");
    if (mlx_prod_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_prod\n");
        return -1;
    }
    mlx_put_along_axis_ptr = dlsym(handle, "mlx_put_along_axis");
    if (mlx_put_along_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_put_along_axis\n");
        return -1;
    }
    mlx_qqmm_ptr = dlsym(handle, "mlx_qqmm");
    if (mlx_qqmm_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_qqmm\n");
        return -1;
    }
    mlx_quantize_ptr = dlsym(handle, "mlx_quantize");
    if (mlx_quantize_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_quantize\n");
        return -1;
    }
    mlx_quantized_matmul_ptr = dlsym(handle, "mlx_quantized_matmul");
    if (mlx_quantized_matmul_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_quantized_matmul\n");
        return -1;
    }
    mlx_radians_ptr = dlsym(handle, "mlx_radians");
    if (mlx_radians_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_radians\n");
        return -1;
    }
    mlx_real_ptr = dlsym(handle, "mlx_real");
    if (mlx_real_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_real\n");
        return -1;
    }
    mlx_reciprocal_ptr = dlsym(handle, "mlx_reciprocal");
    if (mlx_reciprocal_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_reciprocal\n");
        return -1;
    }
    mlx_remainder_ptr = dlsym(handle, "mlx_remainder");
    if (mlx_remainder_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_remainder\n");
        return -1;
    }
    mlx_repeat_axis_ptr = dlsym(handle, "mlx_repeat_axis");
    if (mlx_repeat_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_repeat_axis\n");
        return -1;
    }
    mlx_repeat_ptr = dlsym(handle, "mlx_repeat");
    if (mlx_repeat_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_repeat\n");
        return -1;
    }
    mlx_reshape_ptr = dlsym(handle, "mlx_reshape");
    if (mlx_reshape_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_reshape\n");
        return -1;
    }
    mlx_right_shift_ptr = dlsym(handle, "mlx_right_shift");
    if (mlx_right_shift_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_right_shift\n");
        return -1;
    }
    mlx_roll_axis_ptr = dlsym(handle, "mlx_roll_axis");
    if (mlx_roll_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_roll_axis\n");
        return -1;
    }
    mlx_roll_axes_ptr = dlsym(handle, "mlx_roll_axes");
    if (mlx_roll_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_roll_axes\n");
        return -1;
    }
    mlx_roll_ptr = dlsym(handle, "mlx_roll");
    if (mlx_roll_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_roll\n");
        return -1;
    }
    mlx_round_ptr = dlsym(handle, "mlx_round");
    if (mlx_round_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_round\n");
        return -1;
    }
    mlx_rsqrt_ptr = dlsym(handle, "mlx_rsqrt");
    if (mlx_rsqrt_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_rsqrt\n");
        return -1;
    }
    mlx_scatter_ptr = dlsym(handle, "mlx_scatter");
    if (mlx_scatter_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_scatter\n");
        return -1;
    }
    mlx_scatter_single_ptr = dlsym(handle, "mlx_scatter_single");
    if (mlx_scatter_single_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_scatter_single\n");
        return -1;
    }
    mlx_scatter_add_ptr = dlsym(handle, "mlx_scatter_add");
    if (mlx_scatter_add_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_scatter_add\n");
        return -1;
    }
    mlx_scatter_add_single_ptr = dlsym(handle, "mlx_scatter_add_single");
    if (mlx_scatter_add_single_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_scatter_add_single\n");
        return -1;
    }
    mlx_scatter_add_axis_ptr = dlsym(handle, "mlx_scatter_add_axis");
    if (mlx_scatter_add_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_scatter_add_axis\n");
        return -1;
    }
    mlx_scatter_max_ptr = dlsym(handle, "mlx_scatter_max");
    if (mlx_scatter_max_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_scatter_max\n");
        return -1;
    }
    mlx_scatter_max_single_ptr = dlsym(handle, "mlx_scatter_max_single");
    if (mlx_scatter_max_single_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_scatter_max_single\n");
        return -1;
    }
    mlx_scatter_min_ptr = dlsym(handle, "mlx_scatter_min");
    if (mlx_scatter_min_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_scatter_min\n");
        return -1;
    }
    mlx_scatter_min_single_ptr = dlsym(handle, "mlx_scatter_min_single");
    if (mlx_scatter_min_single_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_scatter_min_single\n");
        return -1;
    }
    mlx_scatter_prod_ptr = dlsym(handle, "mlx_scatter_prod");
    if (mlx_scatter_prod_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_scatter_prod\n");
        return -1;
    }
    mlx_scatter_prod_single_ptr = dlsym(handle, "mlx_scatter_prod_single");
    if (mlx_scatter_prod_single_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_scatter_prod_single\n");
        return -1;
    }
    mlx_segmented_mm_ptr = dlsym(handle, "mlx_segmented_mm");
    if (mlx_segmented_mm_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_segmented_mm\n");
        return -1;
    }
    mlx_sigmoid_ptr = dlsym(handle, "mlx_sigmoid");
    if (mlx_sigmoid_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_sigmoid\n");
        return -1;
    }
    mlx_sign_ptr = dlsym(handle, "mlx_sign");
    if (mlx_sign_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_sign\n");
        return -1;
    }
    mlx_sin_ptr = dlsym(handle, "mlx_sin");
    if (mlx_sin_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_sin\n");
        return -1;
    }
    mlx_sinh_ptr = dlsym(handle, "mlx_sinh");
    if (mlx_sinh_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_sinh\n");
        return -1;
    }
    mlx_slice_ptr = dlsym(handle, "mlx_slice");
    if (mlx_slice_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_slice\n");
        return -1;
    }
    mlx_slice_dynamic_ptr = dlsym(handle, "mlx_slice_dynamic");
    if (mlx_slice_dynamic_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_slice_dynamic\n");
        return -1;
    }
    mlx_slice_update_ptr = dlsym(handle, "mlx_slice_update");
    if (mlx_slice_update_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_slice_update\n");
        return -1;
    }
    mlx_slice_update_dynamic_ptr = dlsym(handle, "mlx_slice_update_dynamic");
    if (mlx_slice_update_dynamic_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_slice_update_dynamic\n");
        return -1;
    }
    mlx_softmax_axes_ptr = dlsym(handle, "mlx_softmax_axes");
    if (mlx_softmax_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_softmax_axes\n");
        return -1;
    }
    mlx_softmax_axis_ptr = dlsym(handle, "mlx_softmax_axis");
    if (mlx_softmax_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_softmax_axis\n");
        return -1;
    }
    mlx_softmax_ptr = dlsym(handle, "mlx_softmax");
    if (mlx_softmax_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_softmax\n");
        return -1;
    }
    mlx_sort_axis_ptr = dlsym(handle, "mlx_sort_axis");
    if (mlx_sort_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_sort_axis\n");
        return -1;
    }
    mlx_sort_ptr = dlsym(handle, "mlx_sort");
    if (mlx_sort_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_sort\n");
        return -1;
    }
    mlx_split_ptr = dlsym(handle, "mlx_split");
    if (mlx_split_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_split\n");
        return -1;
    }
    mlx_split_sections_ptr = dlsym(handle, "mlx_split_sections");
    if (mlx_split_sections_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_split_sections\n");
        return -1;
    }
    mlx_sqrt_ptr = dlsym(handle, "mlx_sqrt");
    if (mlx_sqrt_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_sqrt\n");
        return -1;
    }
    mlx_square_ptr = dlsym(handle, "mlx_square");
    if (mlx_square_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_square\n");
        return -1;
    }
    mlx_squeeze_axes_ptr = dlsym(handle, "mlx_squeeze_axes");
    if (mlx_squeeze_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_squeeze_axes\n");
        return -1;
    }
    mlx_squeeze_axis_ptr = dlsym(handle, "mlx_squeeze_axis");
    if (mlx_squeeze_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_squeeze_axis\n");
        return -1;
    }
    mlx_squeeze_ptr = dlsym(handle, "mlx_squeeze");
    if (mlx_squeeze_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_squeeze\n");
        return -1;
    }
    mlx_stack_axis_ptr = dlsym(handle, "mlx_stack_axis");
    if (mlx_stack_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_stack_axis\n");
        return -1;
    }
    mlx_stack_ptr = dlsym(handle, "mlx_stack");
    if (mlx_stack_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_stack\n");
        return -1;
    }
    mlx_std_axes_ptr = dlsym(handle, "mlx_std_axes");
    if (mlx_std_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_std_axes\n");
        return -1;
    }
    mlx_std_axis_ptr = dlsym(handle, "mlx_std_axis");
    if (mlx_std_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_std_axis\n");
        return -1;
    }
    mlx_std_ptr = dlsym(handle, "mlx_std");
    if (mlx_std_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_std\n");
        return -1;
    }
    mlx_stop_gradient_ptr = dlsym(handle, "mlx_stop_gradient");
    if (mlx_stop_gradient_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_stop_gradient\n");
        return -1;
    }
    mlx_subtract_ptr = dlsym(handle, "mlx_subtract");
    if (mlx_subtract_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_subtract\n");
        return -1;
    }
    mlx_sum_axes_ptr = dlsym(handle, "mlx_sum_axes");
    if (mlx_sum_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_sum_axes\n");
        return -1;
    }
    mlx_sum_axis_ptr = dlsym(handle, "mlx_sum_axis");
    if (mlx_sum_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_sum_axis\n");
        return -1;
    }
    mlx_sum_ptr = dlsym(handle, "mlx_sum");
    if (mlx_sum_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_sum\n");
        return -1;
    }
    mlx_swapaxes_ptr = dlsym(handle, "mlx_swapaxes");
    if (mlx_swapaxes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_swapaxes\n");
        return -1;
    }
    mlx_take_axis_ptr = dlsym(handle, "mlx_take_axis");
    if (mlx_take_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_take_axis\n");
        return -1;
    }
    mlx_take_ptr = dlsym(handle, "mlx_take");
    if (mlx_take_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_take\n");
        return -1;
    }
    mlx_take_along_axis_ptr = dlsym(handle, "mlx_take_along_axis");
    if (mlx_take_along_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_take_along_axis\n");
        return -1;
    }
    mlx_tan_ptr = dlsym(handle, "mlx_tan");
    if (mlx_tan_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_tan\n");
        return -1;
    }
    mlx_tanh_ptr = dlsym(handle, "mlx_tanh");
    if (mlx_tanh_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_tanh\n");
        return -1;
    }
    mlx_tensordot_ptr = dlsym(handle, "mlx_tensordot");
    if (mlx_tensordot_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_tensordot\n");
        return -1;
    }
    mlx_tensordot_axis_ptr = dlsym(handle, "mlx_tensordot_axis");
    if (mlx_tensordot_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_tensordot_axis\n");
        return -1;
    }
    mlx_tile_ptr = dlsym(handle, "mlx_tile");
    if (mlx_tile_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_tile\n");
        return -1;
    }
    mlx_to_fp8_ptr = dlsym(handle, "mlx_to_fp8");
    if (mlx_to_fp8_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_to_fp8\n");
        return -1;
    }
    mlx_topk_axis_ptr = dlsym(handle, "mlx_topk_axis");
    if (mlx_topk_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_topk_axis\n");
        return -1;
    }
    mlx_topk_ptr = dlsym(handle, "mlx_topk");
    if (mlx_topk_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_topk\n");
        return -1;
    }
    mlx_trace_ptr = dlsym(handle, "mlx_trace");
    if (mlx_trace_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_trace\n");
        return -1;
    }
    mlx_transpose_axes_ptr = dlsym(handle, "mlx_transpose_axes");
    if (mlx_transpose_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_transpose_axes\n");
        return -1;
    }
    mlx_transpose_ptr = dlsym(handle, "mlx_transpose");
    if (mlx_transpose_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_transpose\n");
        return -1;
    }
    mlx_tri_ptr = dlsym(handle, "mlx_tri");
    if (mlx_tri_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_tri\n");
        return -1;
    }
    mlx_tril_ptr = dlsym(handle, "mlx_tril");
    if (mlx_tril_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_tril\n");
        return -1;
    }
    mlx_triu_ptr = dlsym(handle, "mlx_triu");
    if (mlx_triu_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_triu\n");
        return -1;
    }
    mlx_unflatten_ptr = dlsym(handle, "mlx_unflatten");
    if (mlx_unflatten_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_unflatten\n");
        return -1;
    }
    mlx_var_axes_ptr = dlsym(handle, "mlx_var_axes");
    if (mlx_var_axes_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_var_axes\n");
        return -1;
    }
    mlx_var_axis_ptr = dlsym(handle, "mlx_var_axis");
    if (mlx_var_axis_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_var_axis\n");
        return -1;
    }
    mlx_var_ptr = dlsym(handle, "mlx_var");
    if (mlx_var_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_var\n");
        return -1;
    }
    mlx_view_ptr = dlsym(handle, "mlx_view");
    if (mlx_view_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_view\n");
        return -1;
    }
    mlx_where_ptr = dlsym(handle, "mlx_where");
    if (mlx_where_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_where\n");
        return -1;
    }
    mlx_zeros_ptr = dlsym(handle, "mlx_zeros");
    if (mlx_zeros_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_zeros\n");
        return -1;
    }
    mlx_zeros_like_ptr = dlsym(handle, "mlx_zeros_like");
    if (mlx_zeros_like_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_zeros_like\n");
        return -1;
    }
    mlx_random_bernoulli_ptr = dlsym(handle, "mlx_random_bernoulli");
    if (mlx_random_bernoulli_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_bernoulli\n");
        return -1;
    }
    mlx_random_bits_ptr = dlsym(handle, "mlx_random_bits");
    if (mlx_random_bits_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_bits\n");
        return -1;
    }
    mlx_random_categorical_shape_ptr = dlsym(handle, "mlx_random_categorical_shape");
    if (mlx_random_categorical_shape_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_categorical_shape\n");
        return -1;
    }
    mlx_random_categorical_num_samples_ptr = dlsym(handle, "mlx_random_categorical_num_samples");
    if (mlx_random_categorical_num_samples_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_categorical_num_samples\n");
        return -1;
    }
    mlx_random_categorical_ptr = dlsym(handle, "mlx_random_categorical");
    if (mlx_random_categorical_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_categorical\n");
        return -1;
    }
    mlx_random_gumbel_ptr = dlsym(handle, "mlx_random_gumbel");
    if (mlx_random_gumbel_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_gumbel\n");
        return -1;
    }
    mlx_random_key_ptr = dlsym(handle, "mlx_random_key");
    if (mlx_random_key_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_key\n");
        return -1;
    }
    mlx_random_laplace_ptr = dlsym(handle, "mlx_random_laplace");
    if (mlx_random_laplace_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_laplace\n");
        return -1;
    }
    mlx_random_multivariate_normal_ptr = dlsym(handle, "mlx_random_multivariate_normal");
    if (mlx_random_multivariate_normal_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_multivariate_normal\n");
        return -1;
    }
    mlx_random_normal_broadcast_ptr = dlsym(handle, "mlx_random_normal_broadcast");
    if (mlx_random_normal_broadcast_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_normal_broadcast\n");
        return -1;
    }
    mlx_random_normal_ptr = dlsym(handle, "mlx_random_normal");
    if (mlx_random_normal_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_normal\n");
        return -1;
    }
    mlx_random_permutation_ptr = dlsym(handle, "mlx_random_permutation");
    if (mlx_random_permutation_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_permutation\n");
        return -1;
    }
    mlx_random_permutation_arange_ptr = dlsym(handle, "mlx_random_permutation_arange");
    if (mlx_random_permutation_arange_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_permutation_arange\n");
        return -1;
    }
    mlx_random_randint_ptr = dlsym(handle, "mlx_random_randint");
    if (mlx_random_randint_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_randint\n");
        return -1;
    }
    mlx_random_seed_ptr = dlsym(handle, "mlx_random_seed");
    if (mlx_random_seed_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_seed\n");
        return -1;
    }
    mlx_random_split_num_ptr = dlsym(handle, "mlx_random_split_num");
    if (mlx_random_split_num_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_split_num\n");
        return -1;
    }
    mlx_random_split_ptr = dlsym(handle, "mlx_random_split");
    if (mlx_random_split_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_split\n");
        return -1;
    }
    mlx_random_truncated_normal_ptr = dlsym(handle, "mlx_random_truncated_normal");
    if (mlx_random_truncated_normal_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_truncated_normal\n");
        return -1;
    }
    mlx_random_uniform_ptr = dlsym(handle, "mlx_random_uniform");
    if (mlx_random_uniform_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_random_uniform\n");
        return -1;
    }
    mlx_stream_new_ptr = dlsym(handle, "mlx_stream_new");
    if (mlx_stream_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_stream_new\n");
        return -1;
    }
    mlx_stream_new_device_ptr = dlsym(handle, "mlx_stream_new_device");
    if (mlx_stream_new_device_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_stream_new_device\n");
        return -1;
    }
    mlx_stream_set_ptr = dlsym(handle, "mlx_stream_set");
    if (mlx_stream_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_stream_set\n");
        return -1;
    }
    mlx_stream_free_ptr = dlsym(handle, "mlx_stream_free");
    if (mlx_stream_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_stream_free\n");
        return -1;
    }
    mlx_stream_tostring_ptr = dlsym(handle, "mlx_stream_tostring");
    if (mlx_stream_tostring_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_stream_tostring\n");
        return -1;
    }
    mlx_stream_equal_ptr = dlsym(handle, "mlx_stream_equal");
    if (mlx_stream_equal_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_stream_equal\n");
        return -1;
    }
    mlx_stream_get_device_ptr = dlsym(handle, "mlx_stream_get_device");
    if (mlx_stream_get_device_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_stream_get_device\n");
        return -1;
    }
    mlx_stream_get_index_ptr = dlsym(handle, "mlx_stream_get_index");
    if (mlx_stream_get_index_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_stream_get_index\n");
        return -1;
    }
    mlx_synchronize_ptr = dlsym(handle, "mlx_synchronize");
    if (mlx_synchronize_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_synchronize\n");
        return -1;
    }
    mlx_get_default_stream_ptr = dlsym(handle, "mlx_get_default_stream");
    if (mlx_get_default_stream_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_get_default_stream\n");
        return -1;
    }
    mlx_set_default_stream_ptr = dlsym(handle, "mlx_set_default_stream");
    if (mlx_set_default_stream_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_set_default_stream\n");
        return -1;
    }
    mlx_default_cpu_stream_new_ptr = dlsym(handle, "mlx_default_cpu_stream_new");
    if (mlx_default_cpu_stream_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_default_cpu_stream_new\n");
        return -1;
    }
    mlx_default_gpu_stream_new_ptr = dlsym(handle, "mlx_default_gpu_stream_new");
    if (mlx_default_gpu_stream_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_default_gpu_stream_new\n");
        return -1;
    }
    mlx_string_new_ptr = dlsym(handle, "mlx_string_new");
    if (mlx_string_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_string_new\n");
        return -1;
    }
    mlx_string_new_data_ptr = dlsym(handle, "mlx_string_new_data");
    if (mlx_string_new_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_string_new_data\n");
        return -1;
    }
    mlx_string_set_ptr = dlsym(handle, "mlx_string_set");
    if (mlx_string_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_string_set\n");
        return -1;
    }
    mlx_string_data_ptr = dlsym(handle, "mlx_string_data");
    if (mlx_string_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_string_data\n");
        return -1;
    }
    mlx_string_free_ptr = dlsym(handle, "mlx_string_free");
    if (mlx_string_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_string_free\n");
        return -1;
    }
    mlx_async_eval_ptr = dlsym(handle, "mlx_async_eval");
    if (mlx_async_eval_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_async_eval\n");
        return -1;
    }
    mlx_checkpoint_ptr = dlsym(handle, "mlx_checkpoint");
    if (mlx_checkpoint_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_checkpoint\n");
        return -1;
    }
    mlx_custom_function_ptr = dlsym(handle, "mlx_custom_function");
    if (mlx_custom_function_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_custom_function\n");
        return -1;
    }
    mlx_custom_vjp_ptr = dlsym(handle, "mlx_custom_vjp");
    if (mlx_custom_vjp_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_custom_vjp\n");
        return -1;
    }
    mlx_eval_ptr = dlsym(handle, "mlx_eval");
    if (mlx_eval_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_eval\n");
        return -1;
    }
    mlx_jvp_ptr = dlsym(handle, "mlx_jvp");
    if (mlx_jvp_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_jvp\n");
        return -1;
    }
    mlx_value_and_grad_ptr = dlsym(handle, "mlx_value_and_grad");
    if (mlx_value_and_grad_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_value_and_grad\n");
        return -1;
    }
    mlx_vjp_ptr = dlsym(handle, "mlx_vjp");
    if (mlx_vjp_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vjp\n");
        return -1;
    }
    mlx_detail_vmap_replace_ptr = dlsym(handle, "mlx_detail_vmap_replace");
    if (mlx_detail_vmap_replace_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_detail_vmap_replace\n");
        return -1;
    }
    mlx_detail_vmap_trace_ptr = dlsym(handle, "mlx_detail_vmap_trace");
    if (mlx_detail_vmap_trace_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_detail_vmap_trace\n");
        return -1;
    }
    mlx_vector_array_new_ptr = dlsym(handle, "mlx_vector_array_new");
    if (mlx_vector_array_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_array_new\n");
        return -1;
    }
    mlx_vector_array_set_ptr = dlsym(handle, "mlx_vector_array_set");
    if (mlx_vector_array_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_array_set\n");
        return -1;
    }
    mlx_vector_array_free_ptr = dlsym(handle, "mlx_vector_array_free");
    if (mlx_vector_array_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_array_free\n");
        return -1;
    }
    mlx_vector_array_new_data_ptr = dlsym(handle, "mlx_vector_array_new_data");
    if (mlx_vector_array_new_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_array_new_data\n");
        return -1;
    }
    mlx_vector_array_new_value_ptr = dlsym(handle, "mlx_vector_array_new_value");
    if (mlx_vector_array_new_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_array_new_value\n");
        return -1;
    }
    mlx_vector_array_set_data_ptr = dlsym(handle, "mlx_vector_array_set_data");
    if (mlx_vector_array_set_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_array_set_data\n");
        return -1;
    }
    mlx_vector_array_set_value_ptr = dlsym(handle, "mlx_vector_array_set_value");
    if (mlx_vector_array_set_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_array_set_value\n");
        return -1;
    }
    mlx_vector_array_append_data_ptr = dlsym(handle, "mlx_vector_array_append_data");
    if (mlx_vector_array_append_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_array_append_data\n");
        return -1;
    }
    mlx_vector_array_append_value_ptr = dlsym(handle, "mlx_vector_array_append_value");
    if (mlx_vector_array_append_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_array_append_value\n");
        return -1;
    }
    mlx_vector_array_size_ptr = dlsym(handle, "mlx_vector_array_size");
    if (mlx_vector_array_size_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_array_size\n");
        return -1;
    }
    mlx_vector_array_get_ptr = dlsym(handle, "mlx_vector_array_get");
    if (mlx_vector_array_get_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_array_get\n");
        return -1;
    }
    mlx_vector_vector_array_new_ptr = dlsym(handle, "mlx_vector_vector_array_new");
    if (mlx_vector_vector_array_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_vector_array_new\n");
        return -1;
    }
    mlx_vector_vector_array_set_ptr = dlsym(handle, "mlx_vector_vector_array_set");
    if (mlx_vector_vector_array_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_vector_array_set\n");
        return -1;
    }
    mlx_vector_vector_array_free_ptr = dlsym(handle, "mlx_vector_vector_array_free");
    if (mlx_vector_vector_array_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_vector_array_free\n");
        return -1;
    }
    mlx_vector_vector_array_new_data_ptr = dlsym(handle, "mlx_vector_vector_array_new_data");
    if (mlx_vector_vector_array_new_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_vector_array_new_data\n");
        return -1;
    }
    mlx_vector_vector_array_new_value_ptr = dlsym(handle, "mlx_vector_vector_array_new_value");
    if (mlx_vector_vector_array_new_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_vector_array_new_value\n");
        return -1;
    }
    mlx_vector_vector_array_set_data_ptr = dlsym(handle, "mlx_vector_vector_array_set_data");
    if (mlx_vector_vector_array_set_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_vector_array_set_data\n");
        return -1;
    }
    mlx_vector_vector_array_set_value_ptr = dlsym(handle, "mlx_vector_vector_array_set_value");
    if (mlx_vector_vector_array_set_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_vector_array_set_value\n");
        return -1;
    }
    mlx_vector_vector_array_append_data_ptr = dlsym(handle, "mlx_vector_vector_array_append_data");
    if (mlx_vector_vector_array_append_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_vector_array_append_data\n");
        return -1;
    }
    mlx_vector_vector_array_append_value_ptr = dlsym(handle, "mlx_vector_vector_array_append_value");
    if (mlx_vector_vector_array_append_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_vector_array_append_value\n");
        return -1;
    }
    mlx_vector_vector_array_size_ptr = dlsym(handle, "mlx_vector_vector_array_size");
    if (mlx_vector_vector_array_size_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_vector_array_size\n");
        return -1;
    }
    mlx_vector_vector_array_get_ptr = dlsym(handle, "mlx_vector_vector_array_get");
    if (mlx_vector_vector_array_get_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_vector_array_get\n");
        return -1;
    }
    mlx_vector_int_new_ptr = dlsym(handle, "mlx_vector_int_new");
    if (mlx_vector_int_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_int_new\n");
        return -1;
    }
    mlx_vector_int_set_ptr = dlsym(handle, "mlx_vector_int_set");
    if (mlx_vector_int_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_int_set\n");
        return -1;
    }
    mlx_vector_int_free_ptr = dlsym(handle, "mlx_vector_int_free");
    if (mlx_vector_int_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_int_free\n");
        return -1;
    }
    mlx_vector_int_new_data_ptr = dlsym(handle, "mlx_vector_int_new_data");
    if (mlx_vector_int_new_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_int_new_data\n");
        return -1;
    }
    mlx_vector_int_new_value_ptr = dlsym(handle, "mlx_vector_int_new_value");
    if (mlx_vector_int_new_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_int_new_value\n");
        return -1;
    }
    mlx_vector_int_set_data_ptr = dlsym(handle, "mlx_vector_int_set_data");
    if (mlx_vector_int_set_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_int_set_data\n");
        return -1;
    }
    mlx_vector_int_set_value_ptr = dlsym(handle, "mlx_vector_int_set_value");
    if (mlx_vector_int_set_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_int_set_value\n");
        return -1;
    }
    mlx_vector_int_append_data_ptr = dlsym(handle, "mlx_vector_int_append_data");
    if (mlx_vector_int_append_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_int_append_data\n");
        return -1;
    }
    mlx_vector_int_append_value_ptr = dlsym(handle, "mlx_vector_int_append_value");
    if (mlx_vector_int_append_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_int_append_value\n");
        return -1;
    }
    mlx_vector_int_size_ptr = dlsym(handle, "mlx_vector_int_size");
    if (mlx_vector_int_size_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_int_size\n");
        return -1;
    }
    mlx_vector_int_get_ptr = dlsym(handle, "mlx_vector_int_get");
    if (mlx_vector_int_get_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_int_get\n");
        return -1;
    }
    mlx_vector_string_new_ptr = dlsym(handle, "mlx_vector_string_new");
    if (mlx_vector_string_new_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_string_new\n");
        return -1;
    }
    mlx_vector_string_set_ptr = dlsym(handle, "mlx_vector_string_set");
    if (mlx_vector_string_set_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_string_set\n");
        return -1;
    }
    mlx_vector_string_free_ptr = dlsym(handle, "mlx_vector_string_free");
    if (mlx_vector_string_free_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_string_free\n");
        return -1;
    }
    mlx_vector_string_new_data_ptr = dlsym(handle, "mlx_vector_string_new_data");
    if (mlx_vector_string_new_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_string_new_data\n");
        return -1;
    }
    mlx_vector_string_new_value_ptr = dlsym(handle, "mlx_vector_string_new_value");
    if (mlx_vector_string_new_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_string_new_value\n");
        return -1;
    }
    mlx_vector_string_set_data_ptr = dlsym(handle, "mlx_vector_string_set_data");
    if (mlx_vector_string_set_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_string_set_data\n");
        return -1;
    }
    mlx_vector_string_set_value_ptr = dlsym(handle, "mlx_vector_string_set_value");
    if (mlx_vector_string_set_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_string_set_value\n");
        return -1;
    }
    mlx_vector_string_append_data_ptr = dlsym(handle, "mlx_vector_string_append_data");
    if (mlx_vector_string_append_data_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_string_append_data\n");
        return -1;
    }
    mlx_vector_string_append_value_ptr = dlsym(handle, "mlx_vector_string_append_value");
    if (mlx_vector_string_append_value_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_string_append_value\n");
        return -1;
    }
    mlx_vector_string_size_ptr = dlsym(handle, "mlx_vector_string_size");
    if (mlx_vector_string_size_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_string_size\n");
        return -1;
    }
    mlx_vector_string_get_ptr = dlsym(handle, "mlx_vector_string_get");
    if (mlx_vector_string_get_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_vector_string_get\n");
        return -1;
    }
    mlx_version_ptr = dlsym(handle, "mlx_version");
    if (mlx_version_ptr == NULL) {
        fprintf(stderr, "MLX: Failed to load symbol: mlx_version\n");
        return -1;
    }
    return 0;
}

// Wrapper function implementations that call through function pointers
size_t mlx_dtype_size(mlx_dtype dtype) {
    return mlx_dtype_size_ptr(dtype);
}

int mlx_array_tostring(mlx_string* str, const mlx_array arr) {
    return mlx_array_tostring_ptr(str, arr);
}

mlx_array mlx_array_new(void) {
    return mlx_array_new_ptr();
}

int mlx_array_free(mlx_array arr) {
    return mlx_array_free_ptr(arr);
}

mlx_array mlx_array_new_bool(bool val) {
    return mlx_array_new_bool_ptr(val);
}

mlx_array mlx_array_new_int(int val) {
    return mlx_array_new_int_ptr(val);
}

mlx_array mlx_array_new_float32(float val) {
    return mlx_array_new_float32_ptr(val);
}

mlx_array mlx_array_new_float(float val) {
    return mlx_array_new_float_ptr(val);
}

mlx_array mlx_array_new_float64(double val) {
    return mlx_array_new_float64_ptr(val);
}

mlx_array mlx_array_new_double(double val) {
    return mlx_array_new_double_ptr(val);
}

mlx_array mlx_array_new_complex(float real_val, float imag_val) {
    return mlx_array_new_complex_ptr(real_val, imag_val);
}

mlx_array mlx_array_new_data(const void* data, const int* shape, int dim, mlx_dtype dtype) {
    return mlx_array_new_data_ptr(data, shape, dim, dtype);
}

int mlx_array_set(mlx_array* arr, const mlx_array src) {
    return mlx_array_set_ptr(arr, src);
}

int mlx_array_set_bool(mlx_array* arr, bool val) {
    return mlx_array_set_bool_ptr(arr, val);
}

int mlx_array_set_int(mlx_array* arr, int val) {
    return mlx_array_set_int_ptr(arr, val);
}

int mlx_array_set_float32(mlx_array* arr, float val) {
    return mlx_array_set_float32_ptr(arr, val);
}

int mlx_array_set_float(mlx_array* arr, float val) {
    return mlx_array_set_float_ptr(arr, val);
}

int mlx_array_set_float64(mlx_array* arr, double val) {
    return mlx_array_set_float64_ptr(arr, val);
}

int mlx_array_set_double(mlx_array* arr, double val) {
    return mlx_array_set_double_ptr(arr, val);
}

int mlx_array_set_complex(mlx_array* arr, float real_val, float imag_val) {
    return mlx_array_set_complex_ptr(arr, real_val, imag_val);
}

int mlx_array_set_data(mlx_array* arr, const void* data, const int* shape, int dim, mlx_dtype dtype) {
    return mlx_array_set_data_ptr(arr, data, shape, dim, dtype);
}

size_t mlx_array_itemsize(const mlx_array arr) {
    return mlx_array_itemsize_ptr(arr);
}

size_t mlx_array_size(const mlx_array arr) {
    return mlx_array_size_ptr(arr);
}

size_t mlx_array_nbytes(const mlx_array arr) {
    return mlx_array_nbytes_ptr(arr);
}

size_t mlx_array_ndim(const mlx_array arr) {
    return mlx_array_ndim_ptr(arr);
}

const int* mlx_array_shape(const mlx_array arr) {
    return mlx_array_shape_ptr(arr);
}

const size_t* mlx_array_strides(const mlx_array arr) {
    return mlx_array_strides_ptr(arr);
}

int mlx_array_dim(const mlx_array arr, int dim) {
    return mlx_array_dim_ptr(arr, dim);
}

mlx_dtype mlx_array_dtype(const mlx_array arr) {
    return mlx_array_dtype_ptr(arr);
}

int mlx_array_eval(mlx_array arr) {
    return mlx_array_eval_ptr(arr);
}

int mlx_array_item_bool(bool* res, const mlx_array arr) {
    return mlx_array_item_bool_ptr(res, arr);
}

int mlx_array_item_uint8(uint8_t* res, const mlx_array arr) {
    return mlx_array_item_uint8_ptr(res, arr);
}

int mlx_array_item_uint16(uint16_t* res, const mlx_array arr) {
    return mlx_array_item_uint16_ptr(res, arr);
}

int mlx_array_item_uint32(uint32_t* res, const mlx_array arr) {
    return mlx_array_item_uint32_ptr(res, arr);
}

int mlx_array_item_uint64(uint64_t* res, const mlx_array arr) {
    return mlx_array_item_uint64_ptr(res, arr);
}

int mlx_array_item_int8(int8_t* res, const mlx_array arr) {
    return mlx_array_item_int8_ptr(res, arr);
}

int mlx_array_item_int16(int16_t* res, const mlx_array arr) {
    return mlx_array_item_int16_ptr(res, arr);
}

int mlx_array_item_int32(int32_t* res, const mlx_array arr) {
    return mlx_array_item_int32_ptr(res, arr);
}

int mlx_array_item_int64(int64_t* res, const mlx_array arr) {
    return mlx_array_item_int64_ptr(res, arr);
}

int mlx_array_item_float32(float* res, const mlx_array arr) {
    return mlx_array_item_float32_ptr(res, arr);
}

int mlx_array_item_float64(double* res, const mlx_array arr) {
    return mlx_array_item_float64_ptr(res, arr);
}

int mlx_array_item_complex64(float _Complex* res, const mlx_array arr) {
    return mlx_array_item_complex64_ptr(res, arr);
}

#if defined(__aarch64__) || defined(_M_ARM64)
int mlx_array_item_float16(float16_t* res, const mlx_array arr) {
    return mlx_array_item_float16_ptr(res, arr);
}
#endif

#if defined(__aarch64__) || defined(_M_ARM64)
int mlx_array_item_bfloat16(bfloat16_t* res, const mlx_array arr) {
    return mlx_array_item_bfloat16_ptr(res, arr);
}
#endif

const bool* mlx_array_data_bool(const mlx_array arr) {
    return mlx_array_data_bool_ptr(arr);
}

const uint8_t* mlx_array_data_uint8(const mlx_array arr) {
    return mlx_array_data_uint8_ptr(arr);
}

const uint16_t* mlx_array_data_uint16(const mlx_array arr) {
    return mlx_array_data_uint16_ptr(arr);
}

const uint32_t* mlx_array_data_uint32(const mlx_array arr) {
    return mlx_array_data_uint32_ptr(arr);
}

const uint64_t* mlx_array_data_uint64(const mlx_array arr) {
    return mlx_array_data_uint64_ptr(arr);
}

const int8_t* mlx_array_data_int8(const mlx_array arr) {
    return mlx_array_data_int8_ptr(arr);
}

const int16_t* mlx_array_data_int16(const mlx_array arr) {
    return mlx_array_data_int16_ptr(arr);
}

const int32_t* mlx_array_data_int32(const mlx_array arr) {
    return mlx_array_data_int32_ptr(arr);
}

const int64_t* mlx_array_data_int64(const mlx_array arr) {
    return mlx_array_data_int64_ptr(arr);
}

const float* mlx_array_data_float32(const mlx_array arr) {
    return mlx_array_data_float32_ptr(arr);
}

const double* mlx_array_data_float64(const mlx_array arr) {
    return mlx_array_data_float64_ptr(arr);
}

const float _Complex* mlx_array_data_complex64(const mlx_array arr) {
    return mlx_array_data_complex64_ptr(arr);
}

#if defined(__aarch64__) || defined(_M_ARM64)
const float16_t* mlx_array_data_float16(const mlx_array arr) {
    return mlx_array_data_float16_ptr(arr);
}
#endif

#if defined(__aarch64__) || defined(_M_ARM64)
const bfloat16_t* mlx_array_data_bfloat16(const mlx_array arr) {
    return mlx_array_data_bfloat16_ptr(arr);
}
#endif

int _mlx_array_is_available(bool* res, const mlx_array arr) {
    return _mlx_array_is_available_ptr(res, arr);
}

int _mlx_array_wait(const mlx_array arr) {
    return _mlx_array_wait_ptr(arr);
}

int _mlx_array_is_contiguous(bool* res, const mlx_array arr) {
    return _mlx_array_is_contiguous_ptr(res, arr);
}

int _mlx_array_is_row_contiguous(bool* res, const mlx_array arr) {
    return _mlx_array_is_row_contiguous_ptr(res, arr);
}

int _mlx_array_is_col_contiguous(bool* res, const mlx_array arr) {
    return _mlx_array_is_col_contiguous_ptr(res, arr);
}

mlx_closure mlx_closure_new(void) {
    return mlx_closure_new_ptr();
}

int mlx_closure_free(mlx_closure cls) {
    return mlx_closure_free_ptr(cls);
}

mlx_closure mlx_closure_new_func(int (*fun)(mlx_vector_array*, const mlx_vector_array)) {
    return mlx_closure_new_func_ptr(fun);
}

mlx_closure mlx_closure_new_func_payload(int (*fun)(mlx_vector_array*, const mlx_vector_array, void*), void* payload, void (*dtor)(void*)) {
    return mlx_closure_new_func_payload_ptr(fun, payload, dtor);
}

int mlx_closure_set(mlx_closure* cls, const mlx_closure src) {
    return mlx_closure_set_ptr(cls, src);
}

int mlx_closure_apply(mlx_vector_array* res, mlx_closure cls, const mlx_vector_array input) {
    return mlx_closure_apply_ptr(res, cls, input);
}

mlx_closure mlx_closure_new_unary(int (*fun)(mlx_array*, const mlx_array)) {
    return mlx_closure_new_unary_ptr(fun);
}

mlx_closure_kwargs mlx_closure_kwargs_new(void) {
    return mlx_closure_kwargs_new_ptr();
}

int mlx_closure_kwargs_free(mlx_closure_kwargs cls) {
    return mlx_closure_kwargs_free_ptr(cls);
}

mlx_closure_kwargs mlx_closure_kwargs_new_func(int (*fun)( mlx_vector_array*, const mlx_vector_array, const mlx_map_string_to_array)) {
    return mlx_closure_kwargs_new_func_ptr(fun);
}

mlx_closure_kwargs mlx_closure_kwargs_new_func_payload(int (*fun)( mlx_vector_array*, const mlx_vector_array, const mlx_map_string_to_array, void*), void* payload, void (*dtor)(void*)) {
    return mlx_closure_kwargs_new_func_payload_ptr(fun, payload, dtor);
}

int mlx_closure_kwargs_set(mlx_closure_kwargs* cls, const mlx_closure_kwargs src) {
    return mlx_closure_kwargs_set_ptr(cls, src);
}

int mlx_closure_kwargs_apply(mlx_vector_array* res, mlx_closure_kwargs cls, const mlx_vector_array input_0, const mlx_map_string_to_array input_1) {
    return mlx_closure_kwargs_apply_ptr(res, cls, input_0, input_1);
}

mlx_closure_value_and_grad mlx_closure_value_and_grad_new(void) {
    return mlx_closure_value_and_grad_new_ptr();
}

int mlx_closure_value_and_grad_free(mlx_closure_value_and_grad cls) {
    return mlx_closure_value_and_grad_free_ptr(cls);
}

mlx_closure_value_and_grad mlx_closure_value_and_grad_new_func(int (*fun)(mlx_vector_array*, mlx_vector_array*, const mlx_vector_array)) {
    return mlx_closure_value_and_grad_new_func_ptr(fun);
}

mlx_closure_value_and_grad mlx_closure_value_and_grad_new_func_payload(int (*fun)( mlx_vector_array*, mlx_vector_array*, const mlx_vector_array, void*), void* payload, void (*dtor)(void*)) {
    return mlx_closure_value_and_grad_new_func_payload_ptr(fun, payload, dtor);
}

int mlx_closure_value_and_grad_set(mlx_closure_value_and_grad* cls, const mlx_closure_value_and_grad src) {
    return mlx_closure_value_and_grad_set_ptr(cls, src);
}

int mlx_closure_value_and_grad_apply(mlx_vector_array* res_0, mlx_vector_array* res_1, mlx_closure_value_and_grad cls, const mlx_vector_array input) {
    return mlx_closure_value_and_grad_apply_ptr(res_0, res_1, cls, input);
}

mlx_closure_custom mlx_closure_custom_new(void) {
    return mlx_closure_custom_new_ptr();
}

int mlx_closure_custom_free(mlx_closure_custom cls) {
    return mlx_closure_custom_free_ptr(cls);
}

mlx_closure_custom mlx_closure_custom_new_func(int (*fun)( mlx_vector_array*, const mlx_vector_array, const mlx_vector_array, const mlx_vector_array)) {
    return mlx_closure_custom_new_func_ptr(fun);
}

mlx_closure_custom mlx_closure_custom_new_func_payload(int (*fun)( mlx_vector_array*, const mlx_vector_array, const mlx_vector_array, const mlx_vector_array, void*), void* payload, void (*dtor)(void*)) {
    return mlx_closure_custom_new_func_payload_ptr(fun, payload, dtor);
}

int mlx_closure_custom_set(mlx_closure_custom* cls, const mlx_closure_custom src) {
    return mlx_closure_custom_set_ptr(cls, src);
}

int mlx_closure_custom_apply(mlx_vector_array* res, mlx_closure_custom cls, const mlx_vector_array input_0, const mlx_vector_array input_1, const mlx_vector_array input_2) {
    return mlx_closure_custom_apply_ptr(res, cls, input_0, input_1, input_2);
}

mlx_closure_custom_jvp mlx_closure_custom_jvp_new(void) {
    return mlx_closure_custom_jvp_new_ptr();
}

int mlx_closure_custom_jvp_free(mlx_closure_custom_jvp cls) {
    return mlx_closure_custom_jvp_free_ptr(cls);
}

mlx_closure_custom_jvp mlx_closure_custom_jvp_new_func(int (*fun)( mlx_vector_array*, const mlx_vector_array, const mlx_vector_array, const int*, size_t _num)) {
    return mlx_closure_custom_jvp_new_func_ptr(fun);
}

mlx_closure_custom_jvp mlx_closure_custom_jvp_new_func_payload(int (*fun)( mlx_vector_array*, const mlx_vector_array, const mlx_vector_array, const int*, size_t _num, void*), void* payload, void (*dtor)(void*)) {
    return mlx_closure_custom_jvp_new_func_payload_ptr(fun, payload, dtor);
}

int mlx_closure_custom_jvp_set(mlx_closure_custom_jvp* cls, const mlx_closure_custom_jvp src) {
    return mlx_closure_custom_jvp_set_ptr(cls, src);
}

int mlx_closure_custom_jvp_apply(mlx_vector_array* res, mlx_closure_custom_jvp cls, const mlx_vector_array input_0, const mlx_vector_array input_1, const int* input_2, size_t input_2_num) {
    return mlx_closure_custom_jvp_apply_ptr(res, cls, input_0, input_1, input_2, input_2_num);
}

mlx_closure_custom_vmap mlx_closure_custom_vmap_new(void) {
    return mlx_closure_custom_vmap_new_ptr();
}

int mlx_closure_custom_vmap_free(mlx_closure_custom_vmap cls) {
    return mlx_closure_custom_vmap_free_ptr(cls);
}

mlx_closure_custom_vmap mlx_closure_custom_vmap_new_func(int (*fun)( mlx_vector_array*, mlx_vector_int*, const mlx_vector_array, const int*, size_t _num)) {
    return mlx_closure_custom_vmap_new_func_ptr(fun);
}

mlx_closure_custom_vmap mlx_closure_custom_vmap_new_func_payload(int (*fun)( mlx_vector_array*, mlx_vector_int*, const mlx_vector_array, const int*, size_t _num, void*), void* payload, void (*dtor)(void*)) {
    return mlx_closure_custom_vmap_new_func_payload_ptr(fun, payload, dtor);
}

int mlx_closure_custom_vmap_set(mlx_closure_custom_vmap* cls, const mlx_closure_custom_vmap src) {
    return mlx_closure_custom_vmap_set_ptr(cls, src);
}

int mlx_closure_custom_vmap_apply(mlx_vector_array* res_0, mlx_vector_int* res_1, mlx_closure_custom_vmap cls, const mlx_vector_array input_0, const int* input_1, size_t input_1_num) {
    return mlx_closure_custom_vmap_apply_ptr(res_0, res_1, cls, input_0, input_1, input_1_num);
}

int mlx_compile(mlx_closure* res, const mlx_closure fun, bool shapeless) {
    return mlx_compile_ptr(res, fun, shapeless);
}

int mlx_detail_compile(mlx_closure* res, const mlx_closure fun, uintptr_t fun_id, bool shapeless, const uint64_t* constants, size_t constants_num) {
    return mlx_detail_compile_ptr(res, fun, fun_id, shapeless, constants, constants_num);
}

int mlx_detail_compile_clear_cache(void) {
    return mlx_detail_compile_clear_cache_ptr();
}

int mlx_detail_compile_erase(uintptr_t fun_id) {
    return mlx_detail_compile_erase_ptr(fun_id);
}

int mlx_disable_compile(void) {
    return mlx_disable_compile_ptr();
}

int mlx_enable_compile(void) {
    return mlx_enable_compile_ptr();
}

int mlx_set_compile_mode(mlx_compile_mode mode) {
    return mlx_set_compile_mode_ptr(mode);
}

mlx_device mlx_device_new(void) {
    return mlx_device_new_ptr();
}

mlx_device mlx_device_new_type(mlx_device_type type, int index) {
    return mlx_device_new_type_ptr(type, index);
}

int mlx_device_free(mlx_device dev) {
    return mlx_device_free_ptr(dev);
}

int mlx_device_set(mlx_device* dev, const mlx_device src) {
    return mlx_device_set_ptr(dev, src);
}

int mlx_device_tostring(mlx_string* str, mlx_device dev) {
    return mlx_device_tostring_ptr(str, dev);
}

bool mlx_device_equal(mlx_device lhs, mlx_device rhs) {
    return mlx_device_equal_ptr(lhs, rhs);
}

int mlx_device_get_index(int* index, mlx_device dev) {
    return mlx_device_get_index_ptr(index, dev);
}

int mlx_device_get_type(mlx_device_type* type, mlx_device dev) {
    return mlx_device_get_type_ptr(type, dev);
}

int mlx_get_default_device(mlx_device* dev) {
    return mlx_get_default_device_ptr(dev);
}

int mlx_set_default_device(mlx_device dev) {
    return mlx_set_default_device_ptr(dev);
}

int mlx_distributed_all_gather(mlx_array* res, const mlx_array x, const mlx_distributed_group group , const mlx_stream S) {
    return mlx_distributed_all_gather_ptr(res, x, group, S);
}

int mlx_distributed_all_max(mlx_array* res, const mlx_array x, const mlx_distributed_group group , const mlx_stream s) {
    return mlx_distributed_all_max_ptr(res, x, group, s);
}

int mlx_distributed_all_min(mlx_array* res, const mlx_array x, const mlx_distributed_group group , const mlx_stream s) {
    return mlx_distributed_all_min_ptr(res, x, group, s);
}

int mlx_distributed_all_sum(mlx_array* res, const mlx_array x, const mlx_distributed_group group , const mlx_stream s) {
    return mlx_distributed_all_sum_ptr(res, x, group, s);
}

int mlx_distributed_recv(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, int src, const mlx_distributed_group group , const mlx_stream s) {
    return mlx_distributed_recv_ptr(res, shape, shape_num, dtype, src, group, s);
}

int mlx_distributed_recv_like(mlx_array* res, const mlx_array x, int src, const mlx_distributed_group group , const mlx_stream s) {
    return mlx_distributed_recv_like_ptr(res, x, src, group, s);
}

int mlx_distributed_send(mlx_array* res, const mlx_array x, int dst, const mlx_distributed_group group , const mlx_stream s) {
    return mlx_distributed_send_ptr(res, x, dst, group, s);
}

int mlx_distributed_sum_scatter(mlx_array* res, const mlx_array x, const mlx_distributed_group group , const mlx_stream s) {
    return mlx_distributed_sum_scatter_ptr(res, x, group, s);
}

int mlx_distributed_group_rank(mlx_distributed_group group) {
    return mlx_distributed_group_rank_ptr(group);
}

int mlx_distributed_group_size(mlx_distributed_group group) {
    return mlx_distributed_group_size_ptr(group);
}

mlx_distributed_group mlx_distributed_group_split(mlx_distributed_group group, int color, int key) {
    return mlx_distributed_group_split_ptr(group, color, key);
}

bool mlx_distributed_is_available(void) {
    return mlx_distributed_is_available_ptr();
}

mlx_distributed_group mlx_distributed_init(bool strict) {
    return mlx_distributed_init_ptr(strict);
}

void mlx_set_error_handler(mlx_error_handler_func handler, void* data, void (*dtor)(void*)) {
    mlx_set_error_handler_ptr(handler, data, dtor);
}

void _mlx_error(const char* file, const int line, const char* fmt, ...) {
    _mlx_error_ptr(file, line, fmt);
}

int mlx_export_function(const char* file, const mlx_closure fun, const mlx_vector_array args, bool shapeless) {
    return mlx_export_function_ptr(file, fun, args, shapeless);
}

int mlx_export_function_kwargs(const char* file, const mlx_closure_kwargs fun, const mlx_vector_array args, const mlx_map_string_to_array kwargs, bool shapeless) {
    return mlx_export_function_kwargs_ptr(file, fun, args, kwargs, shapeless);
}

mlx_function_exporter mlx_function_exporter_new(const char* file, const mlx_closure fun, bool shapeless) {
    return mlx_function_exporter_new_ptr(file, fun, shapeless);
}

int mlx_function_exporter_free(mlx_function_exporter xfunc) {
    return mlx_function_exporter_free_ptr(xfunc);
}

int mlx_function_exporter_apply(const mlx_function_exporter xfunc, const mlx_vector_array args) {
    return mlx_function_exporter_apply_ptr(xfunc, args);
}

int mlx_function_exporter_apply_kwargs(const mlx_function_exporter xfunc, const mlx_vector_array args, const mlx_map_string_to_array kwargs) {
    return mlx_function_exporter_apply_kwargs_ptr(xfunc, args, kwargs);
}

mlx_imported_function mlx_imported_function_new(const char* file) {
    return mlx_imported_function_new_ptr(file);
}

int mlx_imported_function_free(mlx_imported_function xfunc) {
    return mlx_imported_function_free_ptr(xfunc);
}

int mlx_imported_function_apply(mlx_vector_array* res, const mlx_imported_function xfunc, const mlx_vector_array args) {
    return mlx_imported_function_apply_ptr(res, xfunc, args);
}

int mlx_imported_function_apply_kwargs(mlx_vector_array* res, const mlx_imported_function xfunc, const mlx_vector_array args, const mlx_map_string_to_array kwargs) {
    return mlx_imported_function_apply_kwargs_ptr(res, xfunc, args, kwargs);
}

mlx_fast_cuda_kernel_config mlx_fast_cuda_kernel_config_new(void) {
    return mlx_fast_cuda_kernel_config_new_ptr();
}

void mlx_fast_cuda_kernel_config_free(mlx_fast_cuda_kernel_config cls) {
    mlx_fast_cuda_kernel_config_free_ptr(cls);
}

int mlx_fast_cuda_kernel_config_add_output_arg(mlx_fast_cuda_kernel_config cls, const int* shape, size_t size, mlx_dtype dtype) {
    return mlx_fast_cuda_kernel_config_add_output_arg_ptr(cls, shape, size, dtype);
}

int mlx_fast_cuda_kernel_config_set_grid(mlx_fast_cuda_kernel_config cls, int grid1, int grid2, int grid3) {
    return mlx_fast_cuda_kernel_config_set_grid_ptr(cls, grid1, grid2, grid3);
}

int mlx_fast_cuda_kernel_config_set_thread_group(mlx_fast_cuda_kernel_config cls, int thread1, int thread2, int thread3) {
    return mlx_fast_cuda_kernel_config_set_thread_group_ptr(cls, thread1, thread2, thread3);
}

int mlx_fast_cuda_kernel_config_set_init_value(mlx_fast_cuda_kernel_config cls, float value) {
    return mlx_fast_cuda_kernel_config_set_init_value_ptr(cls, value);
}

int mlx_fast_cuda_kernel_config_set_verbose(mlx_fast_cuda_kernel_config cls, bool verbose) {
    return mlx_fast_cuda_kernel_config_set_verbose_ptr(cls, verbose);
}

int mlx_fast_cuda_kernel_config_add_template_arg_dtype(mlx_fast_cuda_kernel_config cls, const char* name, mlx_dtype dtype) {
    return mlx_fast_cuda_kernel_config_add_template_arg_dtype_ptr(cls, name, dtype);
}

int mlx_fast_cuda_kernel_config_add_template_arg_int(mlx_fast_cuda_kernel_config cls, const char* name, int value) {
    return mlx_fast_cuda_kernel_config_add_template_arg_int_ptr(cls, name, value);
}

int mlx_fast_cuda_kernel_config_add_template_arg_bool(mlx_fast_cuda_kernel_config cls, const char* name, bool value) {
    return mlx_fast_cuda_kernel_config_add_template_arg_bool_ptr(cls, name, value);
}

mlx_fast_cuda_kernel mlx_fast_cuda_kernel_new(const char* name, const mlx_vector_string input_names, const mlx_vector_string output_names, const char* source, const char* header, bool ensure_row_contiguous, int shared_memory) {
    return mlx_fast_cuda_kernel_new_ptr(name, input_names, output_names, source, header, ensure_row_contiguous, shared_memory);
}

void mlx_fast_cuda_kernel_free(mlx_fast_cuda_kernel cls) {
    mlx_fast_cuda_kernel_free_ptr(cls);
}

int mlx_fast_cuda_kernel_apply(mlx_vector_array* outputs, mlx_fast_cuda_kernel cls, const mlx_vector_array inputs, const mlx_fast_cuda_kernel_config config, const mlx_stream stream) {
    return mlx_fast_cuda_kernel_apply_ptr(outputs, cls, inputs, config, stream);
}

int mlx_fast_layer_norm(mlx_array* res, const mlx_array x, const mlx_array weight , const mlx_array bias , float eps, const mlx_stream s) {
    return mlx_fast_layer_norm_ptr(res, x, weight, bias, eps, s);
}

mlx_fast_metal_kernel_config mlx_fast_metal_kernel_config_new(void) {
    return mlx_fast_metal_kernel_config_new_ptr();
}

void mlx_fast_metal_kernel_config_free(mlx_fast_metal_kernel_config cls) {
    mlx_fast_metal_kernel_config_free_ptr(cls);
}

int mlx_fast_metal_kernel_config_add_output_arg(mlx_fast_metal_kernel_config cls, const int* shape, size_t size, mlx_dtype dtype) {
    return mlx_fast_metal_kernel_config_add_output_arg_ptr(cls, shape, size, dtype);
}

int mlx_fast_metal_kernel_config_set_grid(mlx_fast_metal_kernel_config cls, int grid1, int grid2, int grid3) {
    return mlx_fast_metal_kernel_config_set_grid_ptr(cls, grid1, grid2, grid3);
}

int mlx_fast_metal_kernel_config_set_thread_group(mlx_fast_metal_kernel_config cls, int thread1, int thread2, int thread3) {
    return mlx_fast_metal_kernel_config_set_thread_group_ptr(cls, thread1, thread2, thread3);
}

int mlx_fast_metal_kernel_config_set_init_value(mlx_fast_metal_kernel_config cls, float value) {
    return mlx_fast_metal_kernel_config_set_init_value_ptr(cls, value);
}

int mlx_fast_metal_kernel_config_set_verbose(mlx_fast_metal_kernel_config cls, bool verbose) {
    return mlx_fast_metal_kernel_config_set_verbose_ptr(cls, verbose);
}

int mlx_fast_metal_kernel_config_add_template_arg_dtype(mlx_fast_metal_kernel_config cls, const char* name, mlx_dtype dtype) {
    return mlx_fast_metal_kernel_config_add_template_arg_dtype_ptr(cls, name, dtype);
}

int mlx_fast_metal_kernel_config_add_template_arg_int(mlx_fast_metal_kernel_config cls, const char* name, int value) {
    return mlx_fast_metal_kernel_config_add_template_arg_int_ptr(cls, name, value);
}

int mlx_fast_metal_kernel_config_add_template_arg_bool(mlx_fast_metal_kernel_config cls, const char* name, bool value) {
    return mlx_fast_metal_kernel_config_add_template_arg_bool_ptr(cls, name, value);
}

mlx_fast_metal_kernel mlx_fast_metal_kernel_new(const char* name, const mlx_vector_string input_names, const mlx_vector_string output_names, const char* source, const char* header, bool ensure_row_contiguous, bool atomic_outputs) {
    return mlx_fast_metal_kernel_new_ptr(name, input_names, output_names, source, header, ensure_row_contiguous, atomic_outputs);
}

void mlx_fast_metal_kernel_free(mlx_fast_metal_kernel cls) {
    mlx_fast_metal_kernel_free_ptr(cls);
}

int mlx_fast_metal_kernel_apply(mlx_vector_array* outputs, mlx_fast_metal_kernel cls, const mlx_vector_array inputs, const mlx_fast_metal_kernel_config config, const mlx_stream stream) {
    return mlx_fast_metal_kernel_apply_ptr(outputs, cls, inputs, config, stream);
}

int mlx_fast_rms_norm(mlx_array* res, const mlx_array x, const mlx_array weight , float eps, const mlx_stream s) {
    return mlx_fast_rms_norm_ptr(res, x, weight, eps, s);
}

int mlx_fast_rope(mlx_array* res, const mlx_array x, int dims, bool traditional, mlx_optional_float base, float scale, int offset, const mlx_array freqs , const mlx_stream s) {
    return mlx_fast_rope_ptr(res, x, dims, traditional, base, scale, offset, freqs, s);
}

int mlx_fast_rope_dynamic(mlx_array* res, const mlx_array x, int dims, bool traditional, mlx_optional_float base, float scale, const mlx_array offset, const mlx_array freqs , const mlx_stream s) {
    return mlx_fast_rope_dynamic_ptr(res, x, dims, traditional, base, scale, offset, freqs, s);
}

int mlx_fast_scaled_dot_product_attention(mlx_array* res, const mlx_array queries, const mlx_array keys, const mlx_array values, float scale, const char* mask_mode, const mlx_array mask_arr , const mlx_array sinks , const mlx_stream s) {
    return mlx_fast_scaled_dot_product_attention_ptr(res, queries, keys, values, scale, mask_mode, mask_arr, sinks, s);
}

int mlx_fft_fft(mlx_array* res, const mlx_array a, int n, int axis, const mlx_stream s) {
    return mlx_fft_fft_ptr(res, a, n, axis, s);
}

int mlx_fft_fft2(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_fft_fft2_ptr(res, a, n, n_num, axes, axes_num, s);
}

int mlx_fft_fftn(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_fft_fftn_ptr(res, a, n, n_num, axes, axes_num, s);
}

int mlx_fft_fftshift(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_fft_fftshift_ptr(res, a, axes, axes_num, s);
}

int mlx_fft_ifft(mlx_array* res, const mlx_array a, int n, int axis, const mlx_stream s) {
    return mlx_fft_ifft_ptr(res, a, n, axis, s);
}

int mlx_fft_ifft2(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_fft_ifft2_ptr(res, a, n, n_num, axes, axes_num, s);
}

int mlx_fft_ifftn(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_fft_ifftn_ptr(res, a, n, n_num, axes, axes_num, s);
}

int mlx_fft_ifftshift(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_fft_ifftshift_ptr(res, a, axes, axes_num, s);
}

int mlx_fft_irfft(mlx_array* res, const mlx_array a, int n, int axis, const mlx_stream s) {
    return mlx_fft_irfft_ptr(res, a, n, axis, s);
}

int mlx_fft_irfft2(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_fft_irfft2_ptr(res, a, n, n_num, axes, axes_num, s);
}

int mlx_fft_irfftn(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_fft_irfftn_ptr(res, a, n, n_num, axes, axes_num, s);
}

int mlx_fft_rfft(mlx_array* res, const mlx_array a, int n, int axis, const mlx_stream s) {
    return mlx_fft_rfft_ptr(res, a, n, axis, s);
}

int mlx_fft_rfft2(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_fft_rfft2_ptr(res, a, n, n_num, axes, axes_num, s);
}

int mlx_fft_rfftn(mlx_array* res, const mlx_array a, const int* n, size_t n_num, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_fft_rfftn_ptr(res, a, n, n_num, axes, axes_num, s);
}

int mlx_load_reader(mlx_array* res, mlx_io_reader in_stream, const mlx_stream s) {
    return mlx_load_reader_ptr(res, in_stream, s);
}

int mlx_load(mlx_array* res, const char* file, const mlx_stream s) {
    return mlx_load_ptr(res, file, s);
}

int mlx_load_safetensors_reader(mlx_map_string_to_array* res_0, mlx_map_string_to_string* res_1, mlx_io_reader in_stream, const mlx_stream s) {
    return mlx_load_safetensors_reader_ptr(res_0, res_1, in_stream, s);
}

int mlx_load_safetensors(mlx_map_string_to_array* res_0, mlx_map_string_to_string* res_1, const char* file, const mlx_stream s) {
    return mlx_load_safetensors_ptr(res_0, res_1, file, s);
}

int mlx_save_writer(mlx_io_writer out_stream, const mlx_array a) {
    return mlx_save_writer_ptr(out_stream, a);
}

int mlx_save(const char* file, const mlx_array a) {
    return mlx_save_ptr(file, a);
}

int mlx_save_safetensors_writer(mlx_io_writer in_stream, const mlx_map_string_to_array param, const mlx_map_string_to_string metadata) {
    return mlx_save_safetensors_writer_ptr(in_stream, param, metadata);
}

int mlx_save_safetensors(const char* file, const mlx_map_string_to_array param, const mlx_map_string_to_string metadata) {
    return mlx_save_safetensors_ptr(file, param, metadata);
}

mlx_io_reader mlx_io_reader_new(void* desc, mlx_io_vtable vtable) {
    return mlx_io_reader_new_ptr(desc, vtable);
}

int mlx_io_reader_descriptor(void** desc_, mlx_io_reader io) {
    return mlx_io_reader_descriptor_ptr(desc_, io);
}

int mlx_io_reader_tostring(mlx_string* str_, mlx_io_reader io) {
    return mlx_io_reader_tostring_ptr(str_, io);
}

int mlx_io_reader_free(mlx_io_reader io) {
    return mlx_io_reader_free_ptr(io);
}

mlx_io_writer mlx_io_writer_new(void* desc, mlx_io_vtable vtable) {
    return mlx_io_writer_new_ptr(desc, vtable);
}

int mlx_io_writer_descriptor(void** desc_, mlx_io_writer io) {
    return mlx_io_writer_descriptor_ptr(desc_, io);
}

int mlx_io_writer_tostring(mlx_string* str_, mlx_io_writer io) {
    return mlx_io_writer_tostring_ptr(str_, io);
}

int mlx_io_writer_free(mlx_io_writer io) {
    return mlx_io_writer_free_ptr(io);
}

int mlx_linalg_cholesky(mlx_array* res, const mlx_array a, bool upper, const mlx_stream s) {
    return mlx_linalg_cholesky_ptr(res, a, upper, s);
}

int mlx_linalg_cholesky_inv(mlx_array* res, const mlx_array a, bool upper, const mlx_stream s) {
    return mlx_linalg_cholesky_inv_ptr(res, a, upper, s);
}

int mlx_linalg_cross(mlx_array* res, const mlx_array a, const mlx_array b, int axis, const mlx_stream s) {
    return mlx_linalg_cross_ptr(res, a, b, axis, s);
}

int mlx_linalg_eig(mlx_array* res_0, mlx_array* res_1, const mlx_array a, const mlx_stream s) {
    return mlx_linalg_eig_ptr(res_0, res_1, a, s);
}

int mlx_linalg_eigh(mlx_array* res_0, mlx_array* res_1, const mlx_array a, const char* UPLO, const mlx_stream s) {
    return mlx_linalg_eigh_ptr(res_0, res_1, a, UPLO, s);
}

int mlx_linalg_eigvals(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_linalg_eigvals_ptr(res, a, s);
}

int mlx_linalg_eigvalsh(mlx_array* res, const mlx_array a, const char* UPLO, const mlx_stream s) {
    return mlx_linalg_eigvalsh_ptr(res, a, UPLO, s);
}

int mlx_linalg_inv(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_linalg_inv_ptr(res, a, s);
}

int mlx_linalg_lu(mlx_vector_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_linalg_lu_ptr(res, a, s);
}

int mlx_linalg_lu_factor(mlx_array* res_0, mlx_array* res_1, const mlx_array a, const mlx_stream s) {
    return mlx_linalg_lu_factor_ptr(res_0, res_1, a, s);
}

int mlx_linalg_norm(mlx_array* res, const mlx_array a, double ord, const int* axis , size_t axis_num, bool keepdims, const mlx_stream s) {
    return mlx_linalg_norm_ptr(res, a, ord, axis, axis_num, keepdims, s);
}

int mlx_linalg_norm_matrix(mlx_array* res, const mlx_array a, const char* ord, const int* axis , size_t axis_num, bool keepdims, const mlx_stream s) {
    return mlx_linalg_norm_matrix_ptr(res, a, ord, axis, axis_num, keepdims, s);
}

int mlx_linalg_norm_l2(mlx_array* res, const mlx_array a, const int* axis , size_t axis_num, bool keepdims, const mlx_stream s) {
    return mlx_linalg_norm_l2_ptr(res, a, axis, axis_num, keepdims, s);
}

int mlx_linalg_pinv(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_linalg_pinv_ptr(res, a, s);
}

int mlx_linalg_qr(mlx_array* res_0, mlx_array* res_1, const mlx_array a, const mlx_stream s) {
    return mlx_linalg_qr_ptr(res_0, res_1, a, s);
}

int mlx_linalg_solve(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_linalg_solve_ptr(res, a, b, s);
}

int mlx_linalg_solve_triangular(mlx_array* res, const mlx_array a, const mlx_array b, bool upper, const mlx_stream s) {
    return mlx_linalg_solve_triangular_ptr(res, a, b, upper, s);
}

int mlx_linalg_svd(mlx_vector_array* res, const mlx_array a, bool compute_uv, const mlx_stream s) {
    return mlx_linalg_svd_ptr(res, a, compute_uv, s);
}

int mlx_linalg_tri_inv(mlx_array* res, const mlx_array a, bool upper, const mlx_stream s) {
    return mlx_linalg_tri_inv_ptr(res, a, upper, s);
}

mlx_map_string_to_array mlx_map_string_to_array_new(void) {
    return mlx_map_string_to_array_new_ptr();
}

int mlx_map_string_to_array_set(mlx_map_string_to_array* map, const mlx_map_string_to_array src) {
    return mlx_map_string_to_array_set_ptr(map, src);
}

int mlx_map_string_to_array_free(mlx_map_string_to_array map) {
    return mlx_map_string_to_array_free_ptr(map);
}

int mlx_map_string_to_array_insert(mlx_map_string_to_array map, const char* key, const mlx_array value) {
    return mlx_map_string_to_array_insert_ptr(map, key, value);
}

int mlx_map_string_to_array_get(mlx_array* value, const mlx_map_string_to_array map, const char* key) {
    return mlx_map_string_to_array_get_ptr(value, map, key);
}

mlx_map_string_to_array_iterator mlx_map_string_to_array_iterator_new(mlx_map_string_to_array map) {
    return mlx_map_string_to_array_iterator_new_ptr(map);
}

int mlx_map_string_to_array_iterator_free(mlx_map_string_to_array_iterator it) {
    return mlx_map_string_to_array_iterator_free_ptr(it);
}

int mlx_map_string_to_array_iterator_next(const char** key, mlx_array* value, mlx_map_string_to_array_iterator it) {
    return mlx_map_string_to_array_iterator_next_ptr(key, value, it);
}

mlx_map_string_to_string mlx_map_string_to_string_new(void) {
    return mlx_map_string_to_string_new_ptr();
}

int mlx_map_string_to_string_set(mlx_map_string_to_string* map, const mlx_map_string_to_string src) {
    return mlx_map_string_to_string_set_ptr(map, src);
}

int mlx_map_string_to_string_free(mlx_map_string_to_string map) {
    return mlx_map_string_to_string_free_ptr(map);
}

int mlx_map_string_to_string_insert(mlx_map_string_to_string map, const char* key, const char* value) {
    return mlx_map_string_to_string_insert_ptr(map, key, value);
}

int mlx_map_string_to_string_get(const char** value, const mlx_map_string_to_string map, const char* key) {
    return mlx_map_string_to_string_get_ptr(value, map, key);
}

mlx_map_string_to_string_iterator mlx_map_string_to_string_iterator_new(mlx_map_string_to_string map) {
    return mlx_map_string_to_string_iterator_new_ptr(map);
}

int mlx_map_string_to_string_iterator_free(mlx_map_string_to_string_iterator it) {
    return mlx_map_string_to_string_iterator_free_ptr(it);
}

int mlx_map_string_to_string_iterator_next(const char** key, const char** value, mlx_map_string_to_string_iterator it) {
    return mlx_map_string_to_string_iterator_next_ptr(key, value, it);
}

int mlx_clear_cache(void) {
    return mlx_clear_cache_ptr();
}

int mlx_get_active_memory(size_t* res) {
    return mlx_get_active_memory_ptr(res);
}

int mlx_get_cache_memory(size_t* res) {
    return mlx_get_cache_memory_ptr(res);
}

int mlx_get_memory_limit(size_t* res) {
    return mlx_get_memory_limit_ptr(res);
}

int mlx_get_peak_memory(size_t* res) {
    return mlx_get_peak_memory_ptr(res);
}

int mlx_reset_peak_memory(void) {
    return mlx_reset_peak_memory_ptr();
}

int mlx_set_cache_limit(size_t* res, size_t limit) {
    return mlx_set_cache_limit_ptr(res, limit);
}

int mlx_set_memory_limit(size_t* res, size_t limit) {
    return mlx_set_memory_limit_ptr(res, limit);
}

int mlx_set_wired_limit(size_t* res, size_t limit) {
    return mlx_set_wired_limit_ptr(res, limit);
}

mlx_metal_device_info_t mlx_metal_device_info(void) {
    return mlx_metal_device_info_ptr();
}

int mlx_metal_is_available(bool* res) {
    return mlx_metal_is_available_ptr(res);
}

int mlx_metal_start_capture(const char* path) {
    return mlx_metal_start_capture_ptr(path);
}

int mlx_metal_stop_capture(void) {
    return mlx_metal_stop_capture_ptr();
}

int mlx_abs(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_abs_ptr(res, a, s);
}

int mlx_add(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_add_ptr(res, a, b, s);
}

int mlx_addmm(mlx_array* res, const mlx_array c, const mlx_array a, const mlx_array b, float alpha, float beta, const mlx_stream s) {
    return mlx_addmm_ptr(res, c, a, b, alpha, beta, s);
}

int mlx_all_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) {
    return mlx_all_axes_ptr(res, a, axes, axes_num, keepdims, s);
}

int mlx_all_axis(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) {
    return mlx_all_axis_ptr(res, a, axis, keepdims, s);
}

int mlx_all(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) {
    return mlx_all_ptr(res, a, keepdims, s);
}

int mlx_allclose(mlx_array* res, const mlx_array a, const mlx_array b, double rtol, double atol, bool equal_nan, const mlx_stream s) {
    return mlx_allclose_ptr(res, a, b, rtol, atol, equal_nan, s);
}

int mlx_any_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) {
    return mlx_any_axes_ptr(res, a, axes, axes_num, keepdims, s);
}

int mlx_any_axis(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) {
    return mlx_any_axis_ptr(res, a, axis, keepdims, s);
}

int mlx_any(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) {
    return mlx_any_ptr(res, a, keepdims, s);
}

int mlx_arange(mlx_array* res, double start, double stop, double step, mlx_dtype dtype, const mlx_stream s) {
    return mlx_arange_ptr(res, start, stop, step, dtype, s);
}

int mlx_arccos(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_arccos_ptr(res, a, s);
}

int mlx_arccosh(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_arccosh_ptr(res, a, s);
}

int mlx_arcsin(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_arcsin_ptr(res, a, s);
}

int mlx_arcsinh(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_arcsinh_ptr(res, a, s);
}

int mlx_arctan(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_arctan_ptr(res, a, s);
}

int mlx_arctan2(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_arctan2_ptr(res, a, b, s);
}

int mlx_arctanh(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_arctanh_ptr(res, a, s);
}

int mlx_argmax_axis(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) {
    return mlx_argmax_axis_ptr(res, a, axis, keepdims, s);
}

int mlx_argmax(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) {
    return mlx_argmax_ptr(res, a, keepdims, s);
}

int mlx_argmin_axis(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) {
    return mlx_argmin_axis_ptr(res, a, axis, keepdims, s);
}

int mlx_argmin(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) {
    return mlx_argmin_ptr(res, a, keepdims, s);
}

int mlx_argpartition_axis(mlx_array* res, const mlx_array a, int kth, int axis, const mlx_stream s) {
    return mlx_argpartition_axis_ptr(res, a, kth, axis, s);
}

int mlx_argpartition(mlx_array* res, const mlx_array a, int kth, const mlx_stream s) {
    return mlx_argpartition_ptr(res, a, kth, s);
}

int mlx_argsort_axis(mlx_array* res, const mlx_array a, int axis, const mlx_stream s) {
    return mlx_argsort_axis_ptr(res, a, axis, s);
}

int mlx_argsort(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_argsort_ptr(res, a, s);
}

int mlx_array_equal(mlx_array* res, const mlx_array a, const mlx_array b, bool equal_nan, const mlx_stream s) {
    return mlx_array_equal_ptr(res, a, b, equal_nan, s);
}

int mlx_as_strided(mlx_array* res, const mlx_array a, const int* shape, size_t shape_num, const int64_t* strides, size_t strides_num, size_t offset, const mlx_stream s) {
    return mlx_as_strided_ptr(res, a, shape, shape_num, strides, strides_num, offset, s);
}

int mlx_astype(mlx_array* res, const mlx_array a, mlx_dtype dtype, const mlx_stream s) {
    return mlx_astype_ptr(res, a, dtype, s);
}

int mlx_atleast_1d(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_atleast_1d_ptr(res, a, s);
}

int mlx_atleast_2d(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_atleast_2d_ptr(res, a, s);
}

int mlx_atleast_3d(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_atleast_3d_ptr(res, a, s);
}

int mlx_bitwise_and(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_bitwise_and_ptr(res, a, b, s);
}

int mlx_bitwise_invert(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_bitwise_invert_ptr(res, a, s);
}

int mlx_bitwise_or(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_bitwise_or_ptr(res, a, b, s);
}

int mlx_bitwise_xor(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_bitwise_xor_ptr(res, a, b, s);
}

int mlx_block_masked_mm(mlx_array* res, const mlx_array a, const mlx_array b, int block_size, const mlx_array mask_out , const mlx_array mask_lhs , const mlx_array mask_rhs , const mlx_stream s) {
    return mlx_block_masked_mm_ptr(res, a, b, block_size, mask_out, mask_lhs, mask_rhs, s);
}

int mlx_broadcast_arrays(mlx_vector_array* res, const mlx_vector_array inputs, const mlx_stream s) {
    return mlx_broadcast_arrays_ptr(res, inputs, s);
}

int mlx_broadcast_to(mlx_array* res, const mlx_array a, const int* shape, size_t shape_num, const mlx_stream s) {
    return mlx_broadcast_to_ptr(res, a, shape, shape_num, s);
}

int mlx_ceil(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_ceil_ptr(res, a, s);
}

int mlx_clip(mlx_array* res, const mlx_array a, const mlx_array a_min , const mlx_array a_max , const mlx_stream s) {
    return mlx_clip_ptr(res, a, a_min, a_max, s);
}

int mlx_concatenate_axis(mlx_array* res, const mlx_vector_array arrays, int axis, const mlx_stream s) {
    return mlx_concatenate_axis_ptr(res, arrays, axis, s);
}

int mlx_concatenate(mlx_array* res, const mlx_vector_array arrays, const mlx_stream s) {
    return mlx_concatenate_ptr(res, arrays, s);
}

int mlx_conjugate(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_conjugate_ptr(res, a, s);
}

int mlx_contiguous(mlx_array* res, const mlx_array a, bool allow_col_major, const mlx_stream s) {
    return mlx_contiguous_ptr(res, a, allow_col_major, s);
}

int mlx_conv1d(mlx_array* res, const mlx_array input, const mlx_array weight, int stride, int padding, int dilation, int groups, const mlx_stream s) {
    return mlx_conv1d_ptr(res, input, weight, stride, padding, dilation, groups, s);
}

int mlx_conv2d(mlx_array* res, const mlx_array input, const mlx_array weight, int stride_0, int stride_1, int padding_0, int padding_1, int dilation_0, int dilation_1, int groups, const mlx_stream s) {
    return mlx_conv2d_ptr(res, input, weight, stride_0, stride_1, padding_0, padding_1, dilation_0, dilation_1, groups, s);
}

int mlx_conv3d(mlx_array* res, const mlx_array input, const mlx_array weight, int stride_0, int stride_1, int stride_2, int padding_0, int padding_1, int padding_2, int dilation_0, int dilation_1, int dilation_2, int groups, const mlx_stream s) {
    return mlx_conv3d_ptr(res, input, weight, stride_0, stride_1, stride_2, padding_0, padding_1, padding_2, dilation_0, dilation_1, dilation_2, groups, s);
}

int mlx_conv_general(mlx_array* res, const mlx_array input, const mlx_array weight, const int* stride, size_t stride_num, const int* padding_lo, size_t padding_lo_num, const int* padding_hi, size_t padding_hi_num, const int* kernel_dilation, size_t kernel_dilation_num, const int* input_dilation, size_t input_dilation_num, int groups, bool flip, const mlx_stream s) {
    return mlx_conv_general_ptr(res, input, weight, stride, stride_num, padding_lo, padding_lo_num, padding_hi, padding_hi_num, kernel_dilation, kernel_dilation_num, input_dilation, input_dilation_num, groups, flip, s);
}

int mlx_conv_transpose1d(mlx_array* res, const mlx_array input, const mlx_array weight, int stride, int padding, int dilation, int output_padding, int groups, const mlx_stream s) {
    return mlx_conv_transpose1d_ptr(res, input, weight, stride, padding, dilation, output_padding, groups, s);
}

int mlx_conv_transpose2d(mlx_array* res, const mlx_array input, const mlx_array weight, int stride_0, int stride_1, int padding_0, int padding_1, int dilation_0, int dilation_1, int output_padding_0, int output_padding_1, int groups, const mlx_stream s) {
    return mlx_conv_transpose2d_ptr(res, input, weight, stride_0, stride_1, padding_0, padding_1, dilation_0, dilation_1, output_padding_0, output_padding_1, groups, s);
}

int mlx_conv_transpose3d(mlx_array* res, const mlx_array input, const mlx_array weight, int stride_0, int stride_1, int stride_2, int padding_0, int padding_1, int padding_2, int dilation_0, int dilation_1, int dilation_2, int output_padding_0, int output_padding_1, int output_padding_2, int groups, const mlx_stream s) {
    return mlx_conv_transpose3d_ptr(res, input, weight, stride_0, stride_1, stride_2, padding_0, padding_1, padding_2, dilation_0, dilation_1, dilation_2, output_padding_0, output_padding_1, output_padding_2, groups, s);
}

int mlx_copy(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_copy_ptr(res, a, s);
}

int mlx_cos(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_cos_ptr(res, a, s);
}

int mlx_cosh(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_cosh_ptr(res, a, s);
}

int mlx_cummax(mlx_array* res, const mlx_array a, int axis, bool reverse, bool inclusive, const mlx_stream s) {
    return mlx_cummax_ptr(res, a, axis, reverse, inclusive, s);
}

int mlx_cummin(mlx_array* res, const mlx_array a, int axis, bool reverse, bool inclusive, const mlx_stream s) {
    return mlx_cummin_ptr(res, a, axis, reverse, inclusive, s);
}

int mlx_cumprod(mlx_array* res, const mlx_array a, int axis, bool reverse, bool inclusive, const mlx_stream s) {
    return mlx_cumprod_ptr(res, a, axis, reverse, inclusive, s);
}

int mlx_cumsum(mlx_array* res, const mlx_array a, int axis, bool reverse, bool inclusive, const mlx_stream s) {
    return mlx_cumsum_ptr(res, a, axis, reverse, inclusive, s);
}

int mlx_degrees(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_degrees_ptr(res, a, s);
}

int mlx_depends(mlx_vector_array* res, const mlx_vector_array inputs, const mlx_vector_array dependencies) {
    return mlx_depends_ptr(res, inputs, dependencies);
}

int mlx_dequantize(mlx_array* res, const mlx_array w, const mlx_array scales, const mlx_array biases , mlx_optional_int group_size, mlx_optional_int bits, const char* mode, mlx_optional_dtype dtype, const mlx_stream s) {
    return mlx_dequantize_ptr(res, w, scales, biases, group_size, bits, mode, dtype, s);
}

int mlx_diag(mlx_array* res, const mlx_array a, int k, const mlx_stream s) {
    return mlx_diag_ptr(res, a, k, s);
}

int mlx_diagonal(mlx_array* res, const mlx_array a, int offset, int axis1, int axis2, const mlx_stream s) {
    return mlx_diagonal_ptr(res, a, offset, axis1, axis2, s);
}

int mlx_divide(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_divide_ptr(res, a, b, s);
}

int mlx_divmod(mlx_vector_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_divmod_ptr(res, a, b, s);
}

int mlx_einsum(mlx_array* res, const char* subscripts, const mlx_vector_array operands, const mlx_stream s) {
    return mlx_einsum_ptr(res, subscripts, operands, s);
}

int mlx_equal(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_equal_ptr(res, a, b, s);
}

int mlx_erf(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_erf_ptr(res, a, s);
}

int mlx_erfinv(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_erfinv_ptr(res, a, s);
}

int mlx_exp(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_exp_ptr(res, a, s);
}

int mlx_expand_dims_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_expand_dims_axes_ptr(res, a, axes, axes_num, s);
}

int mlx_expand_dims(mlx_array* res, const mlx_array a, int axis, const mlx_stream s) {
    return mlx_expand_dims_ptr(res, a, axis, s);
}

int mlx_expm1(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_expm1_ptr(res, a, s);
}

int mlx_eye(mlx_array* res, int n, int m, int k, mlx_dtype dtype, const mlx_stream s) {
    return mlx_eye_ptr(res, n, m, k, dtype, s);
}

int mlx_flatten(mlx_array* res, const mlx_array a, int start_axis, int end_axis, const mlx_stream s) {
    return mlx_flatten_ptr(res, a, start_axis, end_axis, s);
}

int mlx_floor(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_floor_ptr(res, a, s);
}

int mlx_floor_divide(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_floor_divide_ptr(res, a, b, s);
}

int mlx_from_fp8(mlx_array* res, const mlx_array x, mlx_dtype dtype, const mlx_stream s) {
    return mlx_from_fp8_ptr(res, x, dtype, s);
}

int mlx_full(mlx_array* res, const int* shape, size_t shape_num, const mlx_array vals, mlx_dtype dtype, const mlx_stream s) {
    return mlx_full_ptr(res, shape, shape_num, vals, dtype, s);
}

int mlx_full_like(mlx_array* res, const mlx_array a, const mlx_array vals, mlx_dtype dtype, const mlx_stream s) {
    return mlx_full_like_ptr(res, a, vals, dtype, s);
}

int mlx_gather(mlx_array* res, const mlx_array a, const mlx_vector_array indices, const int* axes, size_t axes_num, const int* slice_sizes, size_t slice_sizes_num, const mlx_stream s) {
    return mlx_gather_ptr(res, a, indices, axes, axes_num, slice_sizes, slice_sizes_num, s);
}

int mlx_gather_single(mlx_array* res, const mlx_array a, const mlx_array indices, int axis, const int* slice_sizes, size_t slice_sizes_num, const mlx_stream s) {
    return mlx_gather_single_ptr(res, a, indices, axis, slice_sizes, slice_sizes_num, s);
}

int mlx_gather_mm(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_array lhs_indices , const mlx_array rhs_indices , bool sorted_indices, const mlx_stream s) {
    return mlx_gather_mm_ptr(res, a, b, lhs_indices, rhs_indices, sorted_indices, s);
}

int mlx_gather_qmm(mlx_array* res, const mlx_array x, const mlx_array w, const mlx_array scales, const mlx_array biases , const mlx_array lhs_indices , const mlx_array rhs_indices , bool transpose, mlx_optional_int group_size, mlx_optional_int bits, const char* mode, bool sorted_indices, const mlx_stream s) {
    return mlx_gather_qmm_ptr(res, x, w, scales, biases, lhs_indices, rhs_indices, transpose, group_size, bits, mode, sorted_indices, s);
}

int mlx_greater(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_greater_ptr(res, a, b, s);
}

int mlx_greater_equal(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_greater_equal_ptr(res, a, b, s);
}

int mlx_hadamard_transform(mlx_array* res, const mlx_array a, mlx_optional_float scale, const mlx_stream s) {
    return mlx_hadamard_transform_ptr(res, a, scale, s);
}

int mlx_identity(mlx_array* res, int n, mlx_dtype dtype, const mlx_stream s) {
    return mlx_identity_ptr(res, n, dtype, s);
}

int mlx_imag(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_imag_ptr(res, a, s);
}

int mlx_inner(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_inner_ptr(res, a, b, s);
}

int mlx_isclose(mlx_array* res, const mlx_array a, const mlx_array b, double rtol, double atol, bool equal_nan, const mlx_stream s) {
    return mlx_isclose_ptr(res, a, b, rtol, atol, equal_nan, s);
}

int mlx_isfinite(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_isfinite_ptr(res, a, s);
}

int mlx_isinf(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_isinf_ptr(res, a, s);
}

int mlx_isnan(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_isnan_ptr(res, a, s);
}

int mlx_isneginf(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_isneginf_ptr(res, a, s);
}

int mlx_isposinf(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_isposinf_ptr(res, a, s);
}

int mlx_kron(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_kron_ptr(res, a, b, s);
}

int mlx_left_shift(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_left_shift_ptr(res, a, b, s);
}

int mlx_less(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_less_ptr(res, a, b, s);
}

int mlx_less_equal(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_less_equal_ptr(res, a, b, s);
}

int mlx_linspace(mlx_array* res, double start, double stop, int num, mlx_dtype dtype, const mlx_stream s) {
    return mlx_linspace_ptr(res, start, stop, num, dtype, s);
}

int mlx_log(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_log_ptr(res, a, s);
}

int mlx_log10(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_log10_ptr(res, a, s);
}

int mlx_log1p(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_log1p_ptr(res, a, s);
}

int mlx_log2(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_log2_ptr(res, a, s);
}

int mlx_logaddexp(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_logaddexp_ptr(res, a, b, s);
}

int mlx_logcumsumexp(mlx_array* res, const mlx_array a, int axis, bool reverse, bool inclusive, const mlx_stream s) {
    return mlx_logcumsumexp_ptr(res, a, axis, reverse, inclusive, s);
}

int mlx_logical_and(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_logical_and_ptr(res, a, b, s);
}

int mlx_logical_not(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_logical_not_ptr(res, a, s);
}

int mlx_logical_or(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_logical_or_ptr(res, a, b, s);
}

int mlx_logsumexp_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) {
    return mlx_logsumexp_axes_ptr(res, a, axes, axes_num, keepdims, s);
}

int mlx_logsumexp_axis(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) {
    return mlx_logsumexp_axis_ptr(res, a, axis, keepdims, s);
}

int mlx_logsumexp(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) {
    return mlx_logsumexp_ptr(res, a, keepdims, s);
}

int mlx_masked_scatter(mlx_array* res, const mlx_array a, const mlx_array mask, const mlx_array src, const mlx_stream s) {
    return mlx_masked_scatter_ptr(res, a, mask, src, s);
}

int mlx_matmul(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_matmul_ptr(res, a, b, s);
}

int mlx_max_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) {
    return mlx_max_axes_ptr(res, a, axes, axes_num, keepdims, s);
}

int mlx_max_axis(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) {
    return mlx_max_axis_ptr(res, a, axis, keepdims, s);
}

int mlx_max(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) {
    return mlx_max_ptr(res, a, keepdims, s);
}

int mlx_maximum(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_maximum_ptr(res, a, b, s);
}

int mlx_mean_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) {
    return mlx_mean_axes_ptr(res, a, axes, axes_num, keepdims, s);
}

int mlx_mean_axis(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) {
    return mlx_mean_axis_ptr(res, a, axis, keepdims, s);
}

int mlx_mean(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) {
    return mlx_mean_ptr(res, a, keepdims, s);
}

int mlx_median(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) {
    return mlx_median_ptr(res, a, axes, axes_num, keepdims, s);
}

int mlx_meshgrid(mlx_vector_array* res, const mlx_vector_array arrays, bool sparse, const char* indexing, const mlx_stream s) {
    return mlx_meshgrid_ptr(res, arrays, sparse, indexing, s);
}

int mlx_min_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) {
    return mlx_min_axes_ptr(res, a, axes, axes_num, keepdims, s);
}

int mlx_min_axis(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) {
    return mlx_min_axis_ptr(res, a, axis, keepdims, s);
}

int mlx_min(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) {
    return mlx_min_ptr(res, a, keepdims, s);
}

int mlx_minimum(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_minimum_ptr(res, a, b, s);
}

int mlx_moveaxis(mlx_array* res, const mlx_array a, int source, int destination, const mlx_stream s) {
    return mlx_moveaxis_ptr(res, a, source, destination, s);
}

int mlx_multiply(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_multiply_ptr(res, a, b, s);
}

int mlx_nan_to_num(mlx_array* res, const mlx_array a, float nan, mlx_optional_float posinf, mlx_optional_float neginf, const mlx_stream s) {
    return mlx_nan_to_num_ptr(res, a, nan, posinf, neginf, s);
}

int mlx_negative(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_negative_ptr(res, a, s);
}

int mlx_not_equal(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_not_equal_ptr(res, a, b, s);
}

int mlx_number_of_elements(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool inverted, mlx_dtype dtype, const mlx_stream s) {
    return mlx_number_of_elements_ptr(res, a, axes, axes_num, inverted, dtype, s);
}

int mlx_ones(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_stream s) {
    return mlx_ones_ptr(res, shape, shape_num, dtype, s);
}

int mlx_ones_like(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_ones_like_ptr(res, a, s);
}

int mlx_outer(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_outer_ptr(res, a, b, s);
}

int mlx_pad(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, const int* low_pad_size, size_t low_pad_size_num, const int* high_pad_size, size_t high_pad_size_num, const mlx_array pad_value, const char* mode, const mlx_stream s) {
    return mlx_pad_ptr(res, a, axes, axes_num, low_pad_size, low_pad_size_num, high_pad_size, high_pad_size_num, pad_value, mode, s);
}

int mlx_pad_symmetric(mlx_array* res, const mlx_array a, int pad_width, const mlx_array pad_value, const char* mode, const mlx_stream s) {
    return mlx_pad_symmetric_ptr(res, a, pad_width, pad_value, mode, s);
}

int mlx_partition_axis(mlx_array* res, const mlx_array a, int kth, int axis, const mlx_stream s) {
    return mlx_partition_axis_ptr(res, a, kth, axis, s);
}

int mlx_partition(mlx_array* res, const mlx_array a, int kth, const mlx_stream s) {
    return mlx_partition_ptr(res, a, kth, s);
}

int mlx_power(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_power_ptr(res, a, b, s);
}

int mlx_prod_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) {
    return mlx_prod_axes_ptr(res, a, axes, axes_num, keepdims, s);
}

int mlx_prod_axis(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) {
    return mlx_prod_axis_ptr(res, a, axis, keepdims, s);
}

int mlx_prod(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) {
    return mlx_prod_ptr(res, a, keepdims, s);
}

int mlx_put_along_axis(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array values, int axis, const mlx_stream s) {
    return mlx_put_along_axis_ptr(res, a, indices, values, axis, s);
}

int mlx_qqmm(mlx_array* res, const mlx_array x, const mlx_array w, const mlx_array w_scales , mlx_optional_int group_size, mlx_optional_int bits, const char* mode, const mlx_stream s) {
    return mlx_qqmm_ptr(res, x, w, w_scales, group_size, bits, mode, s);
}

int mlx_quantize(mlx_vector_array* res, const mlx_array w, mlx_optional_int group_size, mlx_optional_int bits, const char* mode, const mlx_stream s) {
    return mlx_quantize_ptr(res, w, group_size, bits, mode, s);
}

int mlx_quantized_matmul(mlx_array* res, const mlx_array x, const mlx_array w, const mlx_array scales, const mlx_array biases , bool transpose, mlx_optional_int group_size, mlx_optional_int bits, const char* mode, const mlx_stream s) {
    return mlx_quantized_matmul_ptr(res, x, w, scales, biases, transpose, group_size, bits, mode, s);
}

int mlx_radians(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_radians_ptr(res, a, s);
}

int mlx_real(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_real_ptr(res, a, s);
}

int mlx_reciprocal(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_reciprocal_ptr(res, a, s);
}

int mlx_remainder(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_remainder_ptr(res, a, b, s);
}

int mlx_repeat_axis(mlx_array* res, const mlx_array arr, int repeats, int axis, const mlx_stream s) {
    return mlx_repeat_axis_ptr(res, arr, repeats, axis, s);
}

int mlx_repeat(mlx_array* res, const mlx_array arr, int repeats, const mlx_stream s) {
    return mlx_repeat_ptr(res, arr, repeats, s);
}

int mlx_reshape(mlx_array* res, const mlx_array a, const int* shape, size_t shape_num, const mlx_stream s) {
    return mlx_reshape_ptr(res, a, shape, shape_num, s);
}

int mlx_right_shift(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_right_shift_ptr(res, a, b, s);
}

int mlx_roll_axis(mlx_array* res, const mlx_array a, const int* shift, size_t shift_num, int axis, const mlx_stream s) {
    return mlx_roll_axis_ptr(res, a, shift, shift_num, axis, s);
}

int mlx_roll_axes(mlx_array* res, const mlx_array a, const int* shift, size_t shift_num, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_roll_axes_ptr(res, a, shift, shift_num, axes, axes_num, s);
}

int mlx_roll(mlx_array* res, const mlx_array a, const int* shift, size_t shift_num, const mlx_stream s) {
    return mlx_roll_ptr(res, a, shift, shift_num, s);
}

int mlx_round(mlx_array* res, const mlx_array a, int decimals, const mlx_stream s) {
    return mlx_round_ptr(res, a, decimals, s);
}

int mlx_rsqrt(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_rsqrt_ptr(res, a, s);
}

int mlx_scatter(mlx_array* res, const mlx_array a, const mlx_vector_array indices, const mlx_array updates, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_scatter_ptr(res, a, indices, updates, axes, axes_num, s);
}

int mlx_scatter_single(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array updates, int axis, const mlx_stream s) {
    return mlx_scatter_single_ptr(res, a, indices, updates, axis, s);
}

int mlx_scatter_add(mlx_array* res, const mlx_array a, const mlx_vector_array indices, const mlx_array updates, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_scatter_add_ptr(res, a, indices, updates, axes, axes_num, s);
}

int mlx_scatter_add_single(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array updates, int axis, const mlx_stream s) {
    return mlx_scatter_add_single_ptr(res, a, indices, updates, axis, s);
}

int mlx_scatter_add_axis(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array values, int axis, const mlx_stream s) {
    return mlx_scatter_add_axis_ptr(res, a, indices, values, axis, s);
}

int mlx_scatter_max(mlx_array* res, const mlx_array a, const mlx_vector_array indices, const mlx_array updates, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_scatter_max_ptr(res, a, indices, updates, axes, axes_num, s);
}

int mlx_scatter_max_single(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array updates, int axis, const mlx_stream s) {
    return mlx_scatter_max_single_ptr(res, a, indices, updates, axis, s);
}

int mlx_scatter_min(mlx_array* res, const mlx_array a, const mlx_vector_array indices, const mlx_array updates, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_scatter_min_ptr(res, a, indices, updates, axes, axes_num, s);
}

int mlx_scatter_min_single(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array updates, int axis, const mlx_stream s) {
    return mlx_scatter_min_single_ptr(res, a, indices, updates, axis, s);
}

int mlx_scatter_prod(mlx_array* res, const mlx_array a, const mlx_vector_array indices, const mlx_array updates, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_scatter_prod_ptr(res, a, indices, updates, axes, axes_num, s);
}

int mlx_scatter_prod_single(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_array updates, int axis, const mlx_stream s) {
    return mlx_scatter_prod_single_ptr(res, a, indices, updates, axis, s);
}

int mlx_segmented_mm(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_array segments, const mlx_stream s) {
    return mlx_segmented_mm_ptr(res, a, b, segments, s);
}

int mlx_sigmoid(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_sigmoid_ptr(res, a, s);
}

int mlx_sign(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_sign_ptr(res, a, s);
}

int mlx_sin(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_sin_ptr(res, a, s);
}

int mlx_sinh(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_sinh_ptr(res, a, s);
}

int mlx_slice(mlx_array* res, const mlx_array a, const int* start, size_t start_num, const int* stop, size_t stop_num, const int* strides, size_t strides_num, const mlx_stream s) {
    return mlx_slice_ptr(res, a, start, start_num, stop, stop_num, strides, strides_num, s);
}

int mlx_slice_dynamic(mlx_array* res, const mlx_array a, const mlx_array start, const int* axes, size_t axes_num, const int* slice_size, size_t slice_size_num, const mlx_stream s) {
    return mlx_slice_dynamic_ptr(res, a, start, axes, axes_num, slice_size, slice_size_num, s);
}

int mlx_slice_update(mlx_array* res, const mlx_array src, const mlx_array update, const int* start, size_t start_num, const int* stop, size_t stop_num, const int* strides, size_t strides_num, const mlx_stream s) {
    return mlx_slice_update_ptr(res, src, update, start, start_num, stop, stop_num, strides, strides_num, s);
}

int mlx_slice_update_dynamic(mlx_array* res, const mlx_array src, const mlx_array update, const mlx_array start, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_slice_update_dynamic_ptr(res, src, update, start, axes, axes_num, s);
}

int mlx_softmax_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool precise, const mlx_stream s) {
    return mlx_softmax_axes_ptr(res, a, axes, axes_num, precise, s);
}

int mlx_softmax_axis(mlx_array* res, const mlx_array a, int axis, bool precise, const mlx_stream s) {
    return mlx_softmax_axis_ptr(res, a, axis, precise, s);
}

int mlx_softmax(mlx_array* res, const mlx_array a, bool precise, const mlx_stream s) {
    return mlx_softmax_ptr(res, a, precise, s);
}

int mlx_sort_axis(mlx_array* res, const mlx_array a, int axis, const mlx_stream s) {
    return mlx_sort_axis_ptr(res, a, axis, s);
}

int mlx_sort(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_sort_ptr(res, a, s);
}

int mlx_split(mlx_vector_array* res, const mlx_array a, int num_splits, int axis, const mlx_stream s) {
    return mlx_split_ptr(res, a, num_splits, axis, s);
}

int mlx_split_sections(mlx_vector_array* res, const mlx_array a, const int* indices, size_t indices_num, int axis, const mlx_stream s) {
    return mlx_split_sections_ptr(res, a, indices, indices_num, axis, s);
}

int mlx_sqrt(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_sqrt_ptr(res, a, s);
}

int mlx_square(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_square_ptr(res, a, s);
}

int mlx_squeeze_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_squeeze_axes_ptr(res, a, axes, axes_num, s);
}

int mlx_squeeze_axis(mlx_array* res, const mlx_array a, int axis, const mlx_stream s) {
    return mlx_squeeze_axis_ptr(res, a, axis, s);
}

int mlx_squeeze(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_squeeze_ptr(res, a, s);
}

int mlx_stack_axis(mlx_array* res, const mlx_vector_array arrays, int axis, const mlx_stream s) {
    return mlx_stack_axis_ptr(res, arrays, axis, s);
}

int mlx_stack(mlx_array* res, const mlx_vector_array arrays, const mlx_stream s) {
    return mlx_stack_ptr(res, arrays, s);
}

int mlx_std_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, int ddof, const mlx_stream s) {
    return mlx_std_axes_ptr(res, a, axes, axes_num, keepdims, ddof, s);
}

int mlx_std_axis(mlx_array* res, const mlx_array a, int axis, bool keepdims, int ddof, const mlx_stream s) {
    return mlx_std_axis_ptr(res, a, axis, keepdims, ddof, s);
}

int mlx_std(mlx_array* res, const mlx_array a, bool keepdims, int ddof, const mlx_stream s) {
    return mlx_std_ptr(res, a, keepdims, ddof, s);
}

int mlx_stop_gradient(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_stop_gradient_ptr(res, a, s);
}

int mlx_subtract(mlx_array* res, const mlx_array a, const mlx_array b, const mlx_stream s) {
    return mlx_subtract_ptr(res, a, b, s);
}

int mlx_sum_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, const mlx_stream s) {
    return mlx_sum_axes_ptr(res, a, axes, axes_num, keepdims, s);
}

int mlx_sum_axis(mlx_array* res, const mlx_array a, int axis, bool keepdims, const mlx_stream s) {
    return mlx_sum_axis_ptr(res, a, axis, keepdims, s);
}

int mlx_sum(mlx_array* res, const mlx_array a, bool keepdims, const mlx_stream s) {
    return mlx_sum_ptr(res, a, keepdims, s);
}

int mlx_swapaxes(mlx_array* res, const mlx_array a, int axis1, int axis2, const mlx_stream s) {
    return mlx_swapaxes_ptr(res, a, axis1, axis2, s);
}

int mlx_take_axis(mlx_array* res, const mlx_array a, const mlx_array indices, int axis, const mlx_stream s) {
    return mlx_take_axis_ptr(res, a, indices, axis, s);
}

int mlx_take(mlx_array* res, const mlx_array a, const mlx_array indices, const mlx_stream s) {
    return mlx_take_ptr(res, a, indices, s);
}

int mlx_take_along_axis(mlx_array* res, const mlx_array a, const mlx_array indices, int axis, const mlx_stream s) {
    return mlx_take_along_axis_ptr(res, a, indices, axis, s);
}

int mlx_tan(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_tan_ptr(res, a, s);
}

int mlx_tanh(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_tanh_ptr(res, a, s);
}

int mlx_tensordot(mlx_array* res, const mlx_array a, const mlx_array b, const int* axes_a, size_t axes_a_num, const int* axes_b, size_t axes_b_num, const mlx_stream s) {
    return mlx_tensordot_ptr(res, a, b, axes_a, axes_a_num, axes_b, axes_b_num, s);
}

int mlx_tensordot_axis(mlx_array* res, const mlx_array a, const mlx_array b, int axis, const mlx_stream s) {
    return mlx_tensordot_axis_ptr(res, a, b, axis, s);
}

int mlx_tile(mlx_array* res, const mlx_array arr, const int* reps, size_t reps_num, const mlx_stream s) {
    return mlx_tile_ptr(res, arr, reps, reps_num, s);
}

int mlx_to_fp8(mlx_array* res, const mlx_array x, const mlx_stream s) {
    return mlx_to_fp8_ptr(res, x, s);
}

int mlx_topk_axis(mlx_array* res, const mlx_array a, int k, int axis, const mlx_stream s) {
    return mlx_topk_axis_ptr(res, a, k, axis, s);
}

int mlx_topk(mlx_array* res, const mlx_array a, int k, const mlx_stream s) {
    return mlx_topk_ptr(res, a, k, s);
}

int mlx_trace(mlx_array* res, const mlx_array a, int offset, int axis1, int axis2, mlx_dtype dtype, const mlx_stream s) {
    return mlx_trace_ptr(res, a, offset, axis1, axis2, dtype, s);
}

int mlx_transpose_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, const mlx_stream s) {
    return mlx_transpose_axes_ptr(res, a, axes, axes_num, s);
}

int mlx_transpose(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_transpose_ptr(res, a, s);
}

int mlx_tri(mlx_array* res, int n, int m, int k, mlx_dtype type, const mlx_stream s) {
    return mlx_tri_ptr(res, n, m, k, type, s);
}

int mlx_tril(mlx_array* res, const mlx_array x, int k, const mlx_stream s) {
    return mlx_tril_ptr(res, x, k, s);
}

int mlx_triu(mlx_array* res, const mlx_array x, int k, const mlx_stream s) {
    return mlx_triu_ptr(res, x, k, s);
}

int mlx_unflatten(mlx_array* res, const mlx_array a, int axis, const int* shape, size_t shape_num, const mlx_stream s) {
    return mlx_unflatten_ptr(res, a, axis, shape, shape_num, s);
}

int mlx_var_axes(mlx_array* res, const mlx_array a, const int* axes, size_t axes_num, bool keepdims, int ddof, const mlx_stream s) {
    return mlx_var_axes_ptr(res, a, axes, axes_num, keepdims, ddof, s);
}

int mlx_var_axis(mlx_array* res, const mlx_array a, int axis, bool keepdims, int ddof, const mlx_stream s) {
    return mlx_var_axis_ptr(res, a, axis, keepdims, ddof, s);
}

int mlx_var(mlx_array* res, const mlx_array a, bool keepdims, int ddof, const mlx_stream s) {
    return mlx_var_ptr(res, a, keepdims, ddof, s);
}

int mlx_view(mlx_array* res, const mlx_array a, mlx_dtype dtype, const mlx_stream s) {
    return mlx_view_ptr(res, a, dtype, s);
}

int mlx_where(mlx_array* res, const mlx_array condition, const mlx_array x, const mlx_array y, const mlx_stream s) {
    return mlx_where_ptr(res, condition, x, y, s);
}

int mlx_zeros(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_stream s) {
    return mlx_zeros_ptr(res, shape, shape_num, dtype, s);
}

int mlx_zeros_like(mlx_array* res, const mlx_array a, const mlx_stream s) {
    return mlx_zeros_like_ptr(res, a, s);
}

int mlx_random_bernoulli(mlx_array* res, const mlx_array p, const int* shape, size_t shape_num, const mlx_array key , const mlx_stream s) {
    return mlx_random_bernoulli_ptr(res, p, shape, shape_num, key, s);
}

int mlx_random_bits(mlx_array* res, const int* shape, size_t shape_num, int width, const mlx_array key , const mlx_stream s) {
    return mlx_random_bits_ptr(res, shape, shape_num, width, key, s);
}

int mlx_random_categorical_shape(mlx_array* res, const mlx_array logits, int axis, const int* shape, size_t shape_num, const mlx_array key , const mlx_stream s) {
    return mlx_random_categorical_shape_ptr(res, logits, axis, shape, shape_num, key, s);
}

int mlx_random_categorical_num_samples(mlx_array* res, const mlx_array logits_, int axis, int num_samples, const mlx_array key , const mlx_stream s) {
    return mlx_random_categorical_num_samples_ptr(res, logits_, axis, num_samples, key, s);
}

int mlx_random_categorical(mlx_array* res, const mlx_array logits, int axis, const mlx_array key , const mlx_stream s) {
    return mlx_random_categorical_ptr(res, logits, axis, key, s);
}

int mlx_random_gumbel(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_array key , const mlx_stream s) {
    return mlx_random_gumbel_ptr(res, shape, shape_num, dtype, key, s);
}

int mlx_random_key(mlx_array* res, uint64_t seed) {
    return mlx_random_key_ptr(res, seed);
}

int mlx_random_laplace(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, float loc, float scale, const mlx_array key , const mlx_stream s) {
    return mlx_random_laplace_ptr(res, shape, shape_num, dtype, loc, scale, key, s);
}

int mlx_random_multivariate_normal(mlx_array* res, const mlx_array mean, const mlx_array cov, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_array key , const mlx_stream s) {
    return mlx_random_multivariate_normal_ptr(res, mean, cov, shape, shape_num, dtype, key, s);
}

int mlx_random_normal_broadcast(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_array loc , const mlx_array scale , const mlx_array key , const mlx_stream s) {
    return mlx_random_normal_broadcast_ptr(res, shape, shape_num, dtype, loc, scale, key, s);
}

int mlx_random_normal(mlx_array* res, const int* shape, size_t shape_num, mlx_dtype dtype, float loc, float scale, const mlx_array key , const mlx_stream s) {
    return mlx_random_normal_ptr(res, shape, shape_num, dtype, loc, scale, key, s);
}

int mlx_random_permutation(mlx_array* res, const mlx_array x, int axis, const mlx_array key , const mlx_stream s) {
    return mlx_random_permutation_ptr(res, x, axis, key, s);
}

int mlx_random_permutation_arange(mlx_array* res, int x, const mlx_array key , const mlx_stream s) {
    return mlx_random_permutation_arange_ptr(res, x, key, s);
}

int mlx_random_randint(mlx_array* res, const mlx_array low, const mlx_array high, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_array key , const mlx_stream s) {
    return mlx_random_randint_ptr(res, low, high, shape, shape_num, dtype, key, s);
}

int mlx_random_seed(uint64_t seed) {
    return mlx_random_seed_ptr(seed);
}

int mlx_random_split_num(mlx_array* res, const mlx_array key, int num, const mlx_stream s) {
    return mlx_random_split_num_ptr(res, key, num, s);
}

int mlx_random_split(mlx_array* res_0, mlx_array* res_1, const mlx_array key, const mlx_stream s) {
    return mlx_random_split_ptr(res_0, res_1, key, s);
}

int mlx_random_truncated_normal(mlx_array* res, const mlx_array lower, const mlx_array upper, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_array key , const mlx_stream s) {
    return mlx_random_truncated_normal_ptr(res, lower, upper, shape, shape_num, dtype, key, s);
}

int mlx_random_uniform(mlx_array* res, const mlx_array low, const mlx_array high, const int* shape, size_t shape_num, mlx_dtype dtype, const mlx_array key , const mlx_stream s) {
    return mlx_random_uniform_ptr(res, low, high, shape, shape_num, dtype, key, s);
}

mlx_stream mlx_stream_new(void) {
    return mlx_stream_new_ptr();
}

mlx_stream mlx_stream_new_device(mlx_device dev) {
    return mlx_stream_new_device_ptr(dev);
}

int mlx_stream_set(mlx_stream* stream, const mlx_stream src) {
    return mlx_stream_set_ptr(stream, src);
}

int mlx_stream_free(mlx_stream stream) {
    return mlx_stream_free_ptr(stream);
}

int mlx_stream_tostring(mlx_string* str, mlx_stream stream) {
    return mlx_stream_tostring_ptr(str, stream);
}

bool mlx_stream_equal(mlx_stream lhs, mlx_stream rhs) {
    return mlx_stream_equal_ptr(lhs, rhs);
}

int mlx_stream_get_device(mlx_device* dev, mlx_stream stream) {
    return mlx_stream_get_device_ptr(dev, stream);
}

int mlx_stream_get_index(int* index, mlx_stream stream) {
    return mlx_stream_get_index_ptr(index, stream);
}

int mlx_synchronize(mlx_stream stream) {
    return mlx_synchronize_ptr(stream);
}

int mlx_get_default_stream(mlx_stream* stream, mlx_device dev) {
    return mlx_get_default_stream_ptr(stream, dev);
}

int mlx_set_default_stream(mlx_stream stream) {
    return mlx_set_default_stream_ptr(stream);
}

mlx_stream mlx_default_cpu_stream_new(void) {
    return mlx_default_cpu_stream_new_ptr();
}

mlx_stream mlx_default_gpu_stream_new(void) {
    return mlx_default_gpu_stream_new_ptr();
}

mlx_string mlx_string_new(void) {
    return mlx_string_new_ptr();
}

mlx_string mlx_string_new_data(const char* str) {
    return mlx_string_new_data_ptr(str);
}

int mlx_string_set(mlx_string* str, const mlx_string src) {
    return mlx_string_set_ptr(str, src);
}

const char* mlx_string_data(mlx_string str) {
    return mlx_string_data_ptr(str);
}

int mlx_string_free(mlx_string str) {
    return mlx_string_free_ptr(str);
}

int mlx_async_eval(const mlx_vector_array outputs) {
    return mlx_async_eval_ptr(outputs);
}

int mlx_checkpoint(mlx_closure* res, const mlx_closure fun) {
    return mlx_checkpoint_ptr(res, fun);
}

int mlx_custom_function(mlx_closure* res, const mlx_closure fun, const mlx_closure_custom fun_vjp , const mlx_closure_custom_jvp fun_jvp , const mlx_closure_custom_vmap fun_vmap) {
    return mlx_custom_function_ptr(res, fun, fun_vjp, fun_jvp, fun_vmap);
}

int mlx_custom_vjp(mlx_closure* res, const mlx_closure fun, const mlx_closure_custom fun_vjp) {
    return mlx_custom_vjp_ptr(res, fun, fun_vjp);
}

int mlx_eval(const mlx_vector_array outputs) {
    return mlx_eval_ptr(outputs);
}

int mlx_jvp(mlx_vector_array* res_0, mlx_vector_array* res_1, const mlx_closure fun, const mlx_vector_array primals, const mlx_vector_array tangents) {
    return mlx_jvp_ptr(res_0, res_1, fun, primals, tangents);
}

int mlx_value_and_grad(mlx_closure_value_and_grad* res, const mlx_closure fun, const int* argnums, size_t argnums_num) {
    return mlx_value_and_grad_ptr(res, fun, argnums, argnums_num);
}

int mlx_vjp(mlx_vector_array* res_0, mlx_vector_array* res_1, const mlx_closure fun, const mlx_vector_array primals, const mlx_vector_array cotangents) {
    return mlx_vjp_ptr(res_0, res_1, fun, primals, cotangents);
}

int mlx_detail_vmap_replace(mlx_vector_array* res, const mlx_vector_array inputs, const mlx_vector_array s_inputs, const mlx_vector_array s_outputs, const int* in_axes, size_t in_axes_num, const int* out_axes, size_t out_axes_num) {
    return mlx_detail_vmap_replace_ptr(res, inputs, s_inputs, s_outputs, in_axes, in_axes_num, out_axes, out_axes_num);
}

int mlx_detail_vmap_trace(mlx_vector_array* res_0, mlx_vector_array* res_1, const mlx_closure fun, const mlx_vector_array inputs, const int* in_axes, size_t in_axes_num) {
    return mlx_detail_vmap_trace_ptr(res_0, res_1, fun, inputs, in_axes, in_axes_num);
}

mlx_vector_array mlx_vector_array_new(void) {
    return mlx_vector_array_new_ptr();
}

int mlx_vector_array_set(mlx_vector_array* vec, const mlx_vector_array src) {
    return mlx_vector_array_set_ptr(vec, src);
}

int mlx_vector_array_free(mlx_vector_array vec) {
    return mlx_vector_array_free_ptr(vec);
}

mlx_vector_array mlx_vector_array_new_data(const mlx_array* data, size_t size) {
    return mlx_vector_array_new_data_ptr(data, size);
}

mlx_vector_array mlx_vector_array_new_value(const mlx_array val) {
    return mlx_vector_array_new_value_ptr(val);
}

int mlx_vector_array_set_data(mlx_vector_array* vec, const mlx_array* data, size_t size) {
    return mlx_vector_array_set_data_ptr(vec, data, size);
}

int mlx_vector_array_set_value(mlx_vector_array* vec, const mlx_array val) {
    return mlx_vector_array_set_value_ptr(vec, val);
}

int mlx_vector_array_append_data(mlx_vector_array vec, const mlx_array* data, size_t size) {
    return mlx_vector_array_append_data_ptr(vec, data, size);
}

int mlx_vector_array_append_value(mlx_vector_array vec, const mlx_array val) {
    return mlx_vector_array_append_value_ptr(vec, val);
}

size_t mlx_vector_array_size(mlx_vector_array vec) {
    return mlx_vector_array_size_ptr(vec);
}

int mlx_vector_array_get(mlx_array* res, const mlx_vector_array vec, size_t idx) {
    return mlx_vector_array_get_ptr(res, vec, idx);
}

mlx_vector_vector_array mlx_vector_vector_array_new(void) {
    return mlx_vector_vector_array_new_ptr();
}

int mlx_vector_vector_array_set(mlx_vector_vector_array* vec, const mlx_vector_vector_array src) {
    return mlx_vector_vector_array_set_ptr(vec, src);
}

int mlx_vector_vector_array_free(mlx_vector_vector_array vec) {
    return mlx_vector_vector_array_free_ptr(vec);
}

mlx_vector_vector_array mlx_vector_vector_array_new_data(const mlx_vector_array* data, size_t size) {
    return mlx_vector_vector_array_new_data_ptr(data, size);
}

mlx_vector_vector_array mlx_vector_vector_array_new_value(const mlx_vector_array val) {
    return mlx_vector_vector_array_new_value_ptr(val);
}

int mlx_vector_vector_array_set_data(mlx_vector_vector_array* vec, const mlx_vector_array* data, size_t size) {
    return mlx_vector_vector_array_set_data_ptr(vec, data, size);
}

int mlx_vector_vector_array_set_value(mlx_vector_vector_array* vec, const mlx_vector_array val) {
    return mlx_vector_vector_array_set_value_ptr(vec, val);
}

int mlx_vector_vector_array_append_data(mlx_vector_vector_array vec, const mlx_vector_array* data, size_t size) {
    return mlx_vector_vector_array_append_data_ptr(vec, data, size);
}

int mlx_vector_vector_array_append_value(mlx_vector_vector_array vec, const mlx_vector_array val) {
    return mlx_vector_vector_array_append_value_ptr(vec, val);
}

size_t mlx_vector_vector_array_size(mlx_vector_vector_array vec) {
    return mlx_vector_vector_array_size_ptr(vec);
}

int mlx_vector_vector_array_get(mlx_vector_array* res, const mlx_vector_vector_array vec, size_t idx) {
    return mlx_vector_vector_array_get_ptr(res, vec, idx);
}

mlx_vector_int mlx_vector_int_new(void) {
    return mlx_vector_int_new_ptr();
}

int mlx_vector_int_set(mlx_vector_int* vec, const mlx_vector_int src) {
    return mlx_vector_int_set_ptr(vec, src);
}

int mlx_vector_int_free(mlx_vector_int vec) {
    return mlx_vector_int_free_ptr(vec);
}

mlx_vector_int mlx_vector_int_new_data(int* data, size_t size) {
    return mlx_vector_int_new_data_ptr(data, size);
}

mlx_vector_int mlx_vector_int_new_value(int val) {
    return mlx_vector_int_new_value_ptr(val);
}

int mlx_vector_int_set_data(mlx_vector_int* vec, int* data, size_t size) {
    return mlx_vector_int_set_data_ptr(vec, data, size);
}

int mlx_vector_int_set_value(mlx_vector_int* vec, int val) {
    return mlx_vector_int_set_value_ptr(vec, val);
}

int mlx_vector_int_append_data(mlx_vector_int vec, int* data, size_t size) {
    return mlx_vector_int_append_data_ptr(vec, data, size);
}

int mlx_vector_int_append_value(mlx_vector_int vec, int val) {
    return mlx_vector_int_append_value_ptr(vec, val);
}

size_t mlx_vector_int_size(mlx_vector_int vec) {
    return mlx_vector_int_size_ptr(vec);
}

int mlx_vector_int_get(int* res, const mlx_vector_int vec, size_t idx) {
    return mlx_vector_int_get_ptr(res, vec, idx);
}

mlx_vector_string mlx_vector_string_new(void) {
    return mlx_vector_string_new_ptr();
}

int mlx_vector_string_set(mlx_vector_string* vec, const mlx_vector_string src) {
    return mlx_vector_string_set_ptr(vec, src);
}

int mlx_vector_string_free(mlx_vector_string vec) {
    return mlx_vector_string_free_ptr(vec);
}

mlx_vector_string mlx_vector_string_new_data(const char** data, size_t size) {
    return mlx_vector_string_new_data_ptr(data, size);
}

mlx_vector_string mlx_vector_string_new_value(const char* val) {
    return mlx_vector_string_new_value_ptr(val);
}

int mlx_vector_string_set_data(mlx_vector_string* vec, const char** data, size_t size) {
    return mlx_vector_string_set_data_ptr(vec, data, size);
}

int mlx_vector_string_set_value(mlx_vector_string* vec, const char* val) {
    return mlx_vector_string_set_value_ptr(vec, val);
}

int mlx_vector_string_append_data(mlx_vector_string vec, const char** data, size_t size) {
    return mlx_vector_string_append_data_ptr(vec, data, size);
}

int mlx_vector_string_append_value(mlx_vector_string vec, const char* val) {
    return mlx_vector_string_append_value_ptr(vec, val);
}

size_t mlx_vector_string_size(mlx_vector_string vec) {
    return mlx_vector_string_size_ptr(vec);
}

int mlx_vector_string_get(char** res, const mlx_vector_string vec, size_t idx) {
    return mlx_vector_string_get_ptr(res, vec, idx);
}

int mlx_version(mlx_string* str_) {
    return mlx_version_ptr(str_);
}

