
// =================================================================================================
// This file is part of the CLBlast project. Author(s):
//   Cedric Nugteren <www.cedricnugteren.nl>
//
// This file implements all the plain C BLAS API calls. This forwards the calls to the C++ API.
//
// =================================================================================================

#include "clblast_c.h"

#include <cstddef>
#include <string>

#include "utilities/clblast_exceptions.hpp"
#include "utilities/utilities.hpp"

// Shortcuts to the clblast namespace
using half = clblast::half;
using float2 = clblast::float2;
using double2 = clblast::double2;

// =================================================================================================
// BLAS level-1 (vector-vector) routines
// =================================================================================================

// ROTG
CLBlastStatusCode CLBlastSrotg(cl_mem sa_buffer, const size_t sa_offset, cl_mem sb_buffer, const size_t sb_offset,
                               cl_mem sc_buffer, const size_t sc_offset, cl_mem ss_buffer, const size_t ss_offset,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Rotg<float>(sa_buffer, sa_offset, sb_buffer, sb_offset, sc_buffer,
                                                               sc_offset, ss_buffer, ss_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDrotg(cl_mem sa_buffer, const size_t sa_offset, cl_mem sb_buffer, const size_t sb_offset,
                               cl_mem sc_buffer, const size_t sc_offset, cl_mem ss_buffer, const size_t ss_offset,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Rotg<double>(sa_buffer, sa_offset, sb_buffer, sb_offset, sc_buffer,
                                                                sc_offset, ss_buffer, ss_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// ROTMG
CLBlastStatusCode CLBlastSrotmg(cl_mem sd1_buffer, const size_t sd1_offset, cl_mem sd2_buffer, const size_t sd2_offset,
                                cl_mem sx1_buffer, const size_t sx1_offset, const cl_mem sy1_buffer,
                                const size_t sy1_offset, cl_mem sparam_buffer, const size_t sparam_offset,
                                cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Rotmg<float>(sd1_buffer, sd1_offset, sd2_buffer, sd2_offset,
                                                                sx1_buffer, sx1_offset, sy1_buffer, sy1_offset,
                                                                sparam_buffer, sparam_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDrotmg(cl_mem sd1_buffer, const size_t sd1_offset, cl_mem sd2_buffer, const size_t sd2_offset,
                                cl_mem sx1_buffer, const size_t sx1_offset, const cl_mem sy1_buffer,
                                const size_t sy1_offset, cl_mem sparam_buffer, const size_t sparam_offset,
                                cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Rotmg<double>(sd1_buffer, sd1_offset, sd2_buffer, sd2_offset,
                                                                 sx1_buffer, sx1_offset, sy1_buffer, sy1_offset,
                                                                 sparam_buffer, sparam_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// ROT
CLBlastStatusCode CLBlastSrot(const size_t n, cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                              cl_mem y_buffer, const size_t y_offset, const size_t y_inc, const float cos,
                              const float sin, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Rot(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, cos, sin, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDrot(const size_t n, cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                              cl_mem y_buffer, const size_t y_offset, const size_t y_inc, const double cos,
                              const double sin, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Rot(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, cos, sin, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// ROTM
CLBlastStatusCode CLBlastSrotm(const size_t n, cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_mem sparam_buffer,
                               const size_t sparam_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Rotm<float>(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc,
                                                               sparam_buffer, sparam_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDrotm(const size_t n, cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_mem sparam_buffer,
                               const size_t sparam_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Rotm<double>(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc,
                                                                sparam_buffer, sparam_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SWAP
CLBlastStatusCode CLBlastSswap(const size_t n, cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Swap<float>(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDswap(const size_t n, cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Swap<double>(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCswap(const size_t n, cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Swap<float2>(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZswap(const size_t n, cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Swap<double2>(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHswap(const size_t n, cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Swap<half>(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SCAL
CLBlastStatusCode CLBlastSscal(const size_t n, const float alpha, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Scal(n, alpha, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDscal(const size_t n, const double alpha, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Scal(n, alpha, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCscal(const size_t n, const cl_float2 alpha, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Scal(n, float2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZscal(const size_t n, const cl_double2 alpha, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Scal(n, double2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHscal(const size_t n, const cl_half alpha, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Scal(n, alpha, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// COPY
CLBlastStatusCode CLBlastScopy(const size_t n, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Copy<float>(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDcopy(const size_t n, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Copy<double>(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCcopy(const size_t n, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Copy<float2>(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZcopy(const size_t n, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Copy<double2>(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHcopy(const size_t n, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Copy<half>(n, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// AXPY
CLBlastStatusCode CLBlastSaxpy(const size_t n, const float alpha, const cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Axpy(n, alpha, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDaxpy(const size_t n, const double alpha, const cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Axpy(n, alpha, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCaxpy(const size_t n, const cl_float2 alpha, const cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Axpy(n, float2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset, x_inc,
                                                        y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZaxpy(const size_t n, const cl_double2 alpha, const cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Axpy(n, double2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset, x_inc,
                                                        y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHaxpy(const size_t n, const cl_half alpha, const cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Axpy(n, alpha, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// DOT
CLBlastStatusCode CLBlastSdot(const size_t n, cl_mem dot_buffer, const size_t dot_offset, const cl_mem x_buffer,
                              const size_t x_offset, const size_t x_inc, const cl_mem y_buffer, const size_t y_offset,
                              const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Dot<float>(n, dot_buffer, dot_offset, x_buffer, x_offset, x_inc,
                                                              y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDdot(const size_t n, cl_mem dot_buffer, const size_t dot_offset, const cl_mem x_buffer,
                              const size_t x_offset, const size_t x_inc, const cl_mem y_buffer, const size_t y_offset,
                              const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Dot<double>(n, dot_buffer, dot_offset, x_buffer, x_offset, x_inc,
                                                               y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHdot(const size_t n, cl_mem dot_buffer, const size_t dot_offset, const cl_mem x_buffer,
                              const size_t x_offset, const size_t x_inc, const cl_mem y_buffer, const size_t y_offset,
                              const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Dot<half>(n, dot_buffer, dot_offset, x_buffer, x_offset, x_inc,
                                                             y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// DOTU
CLBlastStatusCode CLBlastCdotu(const size_t n, cl_mem dot_buffer, const size_t dot_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, const cl_mem y_buffer, const size_t y_offset,
                               const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Dotu<float2>(n, dot_buffer, dot_offset, x_buffer, x_offset, x_inc,
                                                                y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZdotu(const size_t n, cl_mem dot_buffer, const size_t dot_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, const cl_mem y_buffer, const size_t y_offset,
                               const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Dotu<double2>(n, dot_buffer, dot_offset, x_buffer, x_offset, x_inc,
                                                                 y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// DOTC
CLBlastStatusCode CLBlastCdotc(const size_t n, cl_mem dot_buffer, const size_t dot_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, const cl_mem y_buffer, const size_t y_offset,
                               const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Dotc<float2>(n, dot_buffer, dot_offset, x_buffer, x_offset, x_inc,
                                                                y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZdotc(const size_t n, cl_mem dot_buffer, const size_t dot_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, const cl_mem y_buffer, const size_t y_offset,
                               const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Dotc<double2>(n, dot_buffer, dot_offset, x_buffer, x_offset, x_inc,
                                                                 y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// NRM2
CLBlastStatusCode CLBlastSnrm2(const size_t n, cl_mem nrm2_buffer, const size_t nrm2_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Nrm2<float>(n, nrm2_buffer, nrm2_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDnrm2(const size_t n, cl_mem nrm2_buffer, const size_t nrm2_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Nrm2<double>(n, nrm2_buffer, nrm2_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastScnrm2(const size_t n, cl_mem nrm2_buffer, const size_t nrm2_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Nrm2<float2>(n, nrm2_buffer, nrm2_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDznrm2(const size_t n, cl_mem nrm2_buffer, const size_t nrm2_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Nrm2<double2>(n, nrm2_buffer, nrm2_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHnrm2(const size_t n, cl_mem nrm2_buffer, const size_t nrm2_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Nrm2<half>(n, nrm2_buffer, nrm2_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// ASUM
CLBlastStatusCode CLBlastSasum(const size_t n, cl_mem asum_buffer, const size_t asum_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Asum<float>(n, asum_buffer, asum_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDasum(const size_t n, cl_mem asum_buffer, const size_t asum_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Asum<double>(n, asum_buffer, asum_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastScasum(const size_t n, cl_mem asum_buffer, const size_t asum_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Asum<float2>(n, asum_buffer, asum_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDzasum(const size_t n, cl_mem asum_buffer, const size_t asum_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Asum<double2>(n, asum_buffer, asum_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHasum(const size_t n, cl_mem asum_buffer, const size_t asum_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Asum<half>(n, asum_buffer, asum_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SUM
CLBlastStatusCode CLBlastSsum(const size_t n, cl_mem sum_buffer, const size_t sum_offset, const cl_mem x_buffer,
                              const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Sum<float>(n, sum_buffer, sum_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDsum(const size_t n, cl_mem sum_buffer, const size_t sum_offset, const cl_mem x_buffer,
                              const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Sum<double>(n, sum_buffer, sum_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastScsum(const size_t n, cl_mem sum_buffer, const size_t sum_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Sum<float2>(n, sum_buffer, sum_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDzsum(const size_t n, cl_mem sum_buffer, const size_t sum_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Sum<double2>(n, sum_buffer, sum_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHsum(const size_t n, cl_mem sum_buffer, const size_t sum_offset, const cl_mem x_buffer,
                              const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Sum<half>(n, sum_buffer, sum_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// AMAX
CLBlastStatusCode CLBlastiSamax(const size_t n, cl_mem imax_buffer, const size_t imax_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Amax<float>(n, imax_buffer, imax_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiDamax(const size_t n, cl_mem imax_buffer, const size_t imax_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Amax<double>(n, imax_buffer, imax_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiCamax(const size_t n, cl_mem imax_buffer, const size_t imax_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Amax<float2>(n, imax_buffer, imax_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiZamax(const size_t n, cl_mem imax_buffer, const size_t imax_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Amax<double2>(n, imax_buffer, imax_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiHamax(const size_t n, cl_mem imax_buffer, const size_t imax_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Amax<half>(n, imax_buffer, imax_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// AMIN
CLBlastStatusCode CLBlastiSamin(const size_t n, cl_mem imin_buffer, const size_t imin_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Amin<float>(n, imin_buffer, imin_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiDamin(const size_t n, cl_mem imin_buffer, const size_t imin_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Amin<double>(n, imin_buffer, imin_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiCamin(const size_t n, cl_mem imin_buffer, const size_t imin_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Amin<float2>(n, imin_buffer, imin_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiZamin(const size_t n, cl_mem imin_buffer, const size_t imin_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Amin<double2>(n, imin_buffer, imin_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiHamin(const size_t n, cl_mem imin_buffer, const size_t imin_offset, const cl_mem x_buffer,
                                const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Amin<half>(n, imin_buffer, imin_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// MAX
CLBlastStatusCode CLBlastiSmax(const size_t n, cl_mem imax_buffer, const size_t imax_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Max<float>(n, imax_buffer, imax_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiDmax(const size_t n, cl_mem imax_buffer, const size_t imax_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Max<double>(n, imax_buffer, imax_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiCmax(const size_t n, cl_mem imax_buffer, const size_t imax_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Max<float2>(n, imax_buffer, imax_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiZmax(const size_t n, cl_mem imax_buffer, const size_t imax_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Max<double2>(n, imax_buffer, imax_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiHmax(const size_t n, cl_mem imax_buffer, const size_t imax_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Max<half>(n, imax_buffer, imax_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// MIN
CLBlastStatusCode CLBlastiSmin(const size_t n, cl_mem imin_buffer, const size_t imin_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Min<float>(n, imin_buffer, imin_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiDmin(const size_t n, cl_mem imin_buffer, const size_t imin_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Min<double>(n, imin_buffer, imin_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiCmin(const size_t n, cl_mem imin_buffer, const size_t imin_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Min<float2>(n, imin_buffer, imin_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiZmin(const size_t n, cl_mem imin_buffer, const size_t imin_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Min<double2>(n, imin_buffer, imin_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastiHmin(const size_t n, cl_mem imin_buffer, const size_t imin_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Min<half>(n, imin_buffer, imin_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// =================================================================================================
// BLAS level-2 (matrix-vector) routines
// =================================================================================================

// GEMV
CLBlastStatusCode CLBlastSgemv(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                               const size_t n, const float alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const float beta, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Gemv(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n, alpha, a_buffer,
        a_offset, a_ld, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDgemv(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                               const size_t n, const double alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const double beta, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Gemv(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n, alpha, a_buffer,
        a_offset, a_ld, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCgemv(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                               const size_t n, const cl_float2 alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_float2 beta, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gemv(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n,
                      float2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc,
                      float2{beta.s[0], beta.s[1]}, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZgemv(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                               const size_t n, const cl_double2 alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_double2 beta, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gemv(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n,
                      double2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc,
                      double2{beta.s[0], beta.s[1]}, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHgemv(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                               const size_t n, const cl_half alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_half beta, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Gemv(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n, alpha, a_buffer,
        a_offset, a_ld, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// GBMV
CLBlastStatusCode CLBlastSgbmv(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                               const size_t n, const size_t kl, const size_t ku, const float alpha,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, const float beta, cl_mem y_buffer,
                               const size_t y_offset, const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Gbmv(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n, kl, ku, alpha,
        a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDgbmv(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                               const size_t n, const size_t kl, const size_t ku, const double alpha,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, const double beta, cl_mem y_buffer,
                               const size_t y_offset, const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Gbmv(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n, kl, ku, alpha,
        a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCgbmv(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                               const size_t n, const size_t kl, const size_t ku, const cl_float2 alpha,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, const cl_float2 beta, cl_mem y_buffer,
                               const size_t y_offset, const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gbmv(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n, kl, ku,
                      float2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc,
                      float2{beta.s[0], beta.s[1]}, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZgbmv(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                               const size_t n, const size_t kl, const size_t ku, const cl_double2 alpha,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, const cl_double2 beta, cl_mem y_buffer,
                               const size_t y_offset, const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gbmv(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n, kl, ku,
                      double2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc,
                      double2{beta.s[0], beta.s[1]}, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHgbmv(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                               const size_t n, const size_t kl, const size_t ku, const cl_half alpha,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, const cl_half beta, cl_mem y_buffer,
                               const size_t y_offset, const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Gbmv(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n, kl, ku, alpha,
        a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// HEMV
CLBlastStatusCode CLBlastChemv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const cl_float2 alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_float2 beta,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Hemv(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n,
                      float2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc,
                      float2{beta.s[0], beta.s[1]}, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZhemv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const cl_double2 alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_double2 beta,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Hemv(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n,
                      double2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc,
                      double2{beta.s[0], beta.s[1]}, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// HBMV
CLBlastStatusCode CLBlastChbmv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const size_t k, const cl_float2 alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_float2 beta, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Hbmv(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, k,
                      float2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc,
                      float2{beta.s[0], beta.s[1]}, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZhbmv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const size_t k, const cl_double2 alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_double2 beta, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Hbmv(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, k,
                      double2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc,
                      double2{beta.s[0], beta.s[1]}, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// HPMV
CLBlastStatusCode CLBlastChpmv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const cl_float2 alpha, const cl_mem ap_buffer, const size_t ap_offset,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_float2 beta,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Hpmv(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n,
                      float2{alpha.s[0], alpha.s[1]}, ap_buffer, ap_offset, x_buffer, x_offset, x_inc,
                      float2{beta.s[0], beta.s[1]}, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZhpmv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const cl_double2 alpha, const cl_mem ap_buffer, const size_t ap_offset,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_double2 beta,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Hpmv(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n,
                      double2{alpha.s[0], alpha.s[1]}, ap_buffer, ap_offset, x_buffer, x_offset, x_inc,
                      double2{beta.s[0], beta.s[1]}, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SYMV
CLBlastStatusCode CLBlastSsymv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const float alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const float beta,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Symv(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, alpha, a_buffer, a_offset,
        a_ld, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDsymv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const double alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const double beta,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Symv(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, alpha, a_buffer, a_offset,
        a_ld, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHsymv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const cl_half alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_half beta,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Symv(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, alpha, a_buffer, a_offset,
        a_ld, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SBMV
CLBlastStatusCode CLBlastSsbmv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const size_t k, const float alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const float beta, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Sbmv(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, k, alpha, a_buffer, a_offset,
        a_ld, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDsbmv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const size_t k, const double alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const double beta, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Sbmv(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, k, alpha, a_buffer, a_offset,
        a_ld, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHsbmv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const size_t k, const cl_half alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_half beta, cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Sbmv(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, k, alpha, a_buffer, a_offset,
        a_ld, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SPMV
CLBlastStatusCode CLBlastSspmv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const float alpha, const cl_mem ap_buffer, const size_t ap_offset, const cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, const float beta, cl_mem y_buffer,
                               const size_t y_offset, const size_t y_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Spmv(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, alpha,
                      ap_buffer, ap_offset, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDspmv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const double alpha, const cl_mem ap_buffer, const size_t ap_offset,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const double beta,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Spmv(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, alpha,
                      ap_buffer, ap_offset, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHspmv(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const cl_half alpha, const cl_mem ap_buffer, const size_t ap_offset,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_half beta,
                               cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Spmv(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, alpha,
                      ap_buffer, ap_offset, x_buffer, x_offset, x_inc, beta, y_buffer, y_offset, y_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// TRMV
CLBlastStatusCode CLBlastStrmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trmv<float>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                             static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                             a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDtrmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trmv<double>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                              static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                              a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCtrmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trmv<float2>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                              static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                              a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZtrmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trmv<double2>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                               static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal),
                               n, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHtrmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trmv<half>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                            static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                            a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// TBMV
CLBlastStatusCode CLBlastStbmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const size_t k, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               cl_mem x_buffer, const size_t x_offset, const size_t x_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tbmv<float>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                             static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                             k, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDtbmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const size_t k, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               cl_mem x_buffer, const size_t x_offset, const size_t x_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tbmv<double>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                              static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                              k, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCtbmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const size_t k, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               cl_mem x_buffer, const size_t x_offset, const size_t x_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tbmv<float2>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                              static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                              k, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZtbmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const size_t k, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               cl_mem x_buffer, const size_t x_offset, const size_t x_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tbmv<double2>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                               static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal),
                               n, k, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHtbmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const size_t k, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               cl_mem x_buffer, const size_t x_offset, const size_t x_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tbmv<half>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                            static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                            k, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// TPMV
CLBlastStatusCode CLBlastStpmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem ap_buffer, const size_t ap_offset, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tpmv<float>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                             static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                             ap_buffer, ap_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDtpmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem ap_buffer, const size_t ap_offset, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tpmv<double>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                              static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                              ap_buffer, ap_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCtpmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem ap_buffer, const size_t ap_offset, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tpmv<float2>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                              static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                              ap_buffer, ap_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZtpmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem ap_buffer, const size_t ap_offset, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tpmv<double2>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                               static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal),
                               n, ap_buffer, ap_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHtpmv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem ap_buffer, const size_t ap_offset, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tpmv<half>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                            static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                            ap_buffer, ap_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// TRSV
CLBlastStatusCode CLBlastStrsv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trsv<float>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                             static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                             a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDtrsv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trsv<double>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                              static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                              a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCtrsv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trsv<float2>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                              static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                              a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZtrsv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_mem x_buffer,
                               const size_t x_offset, const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trsv<double2>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                               static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal),
                               n, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// TBSV
CLBlastStatusCode CLBlastStbsv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const size_t k, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               cl_mem x_buffer, const size_t x_offset, const size_t x_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tbsv<float>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                             static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                             k, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDtbsv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const size_t k, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               cl_mem x_buffer, const size_t x_offset, const size_t x_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tbsv<double>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                              static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                              k, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCtbsv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const size_t k, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               cl_mem x_buffer, const size_t x_offset, const size_t x_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tbsv<float2>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                              static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                              k, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZtbsv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const size_t k, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               cl_mem x_buffer, const size_t x_offset, const size_t x_inc, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tbsv<double2>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                               static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal),
                               n, k, a_buffer, a_offset, a_ld, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// TPSV
CLBlastStatusCode CLBlastStpsv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem ap_buffer, const size_t ap_offset, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tpsv<float>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                             static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                             ap_buffer, ap_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDtpsv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem ap_buffer, const size_t ap_offset, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tpsv<double>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                              static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                              ap_buffer, ap_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCtpsv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem ap_buffer, const size_t ap_offset, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tpsv<float2>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                              static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal), n,
                              ap_buffer, ap_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZtpsv(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t n,
                               const cl_mem ap_buffer, const size_t ap_offset, cl_mem x_buffer, const size_t x_offset,
                               const size_t x_inc, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Tpsv<double2>(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                               static_cast<clblast::Transpose>(a_transpose), static_cast<clblast::Diagonal>(diagonal),
                               n, ap_buffer, ap_offset, x_buffer, x_offset, x_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// GER
CLBlastStatusCode CLBlastSger(const CLBlastLayout layout, const size_t m, const size_t n, const float alpha,
                              const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_mem y_buffer,
                              const size_t y_offset, const size_t y_inc, cl_mem a_buffer, const size_t a_offset,
                              const size_t a_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Ger(static_cast<clblast::Layout>(layout), m, n, alpha, x_buffer,
                                                       x_offset, x_inc, y_buffer, y_offset, y_inc, a_buffer, a_offset,
                                                       a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDger(const CLBlastLayout layout, const size_t m, const size_t n, const double alpha,
                              const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_mem y_buffer,
                              const size_t y_offset, const size_t y_inc, cl_mem a_buffer, const size_t a_offset,
                              const size_t a_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Ger(static_cast<clblast::Layout>(layout), m, n, alpha, x_buffer,
                                                       x_offset, x_inc, y_buffer, y_offset, y_inc, a_buffer, a_offset,
                                                       a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHger(const CLBlastLayout layout, const size_t m, const size_t n, const cl_half alpha,
                              const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_mem y_buffer,
                              const size_t y_offset, const size_t y_inc, cl_mem a_buffer, const size_t a_offset,
                              const size_t a_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Ger(static_cast<clblast::Layout>(layout), m, n, alpha, x_buffer,
                                                       x_offset, x_inc, y_buffer, y_offset, y_inc, a_buffer, a_offset,
                                                       a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// GERU
CLBlastStatusCode CLBlastCgeru(const CLBlastLayout layout, const size_t m, const size_t n, const cl_float2 alpha,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_mem y_buffer,
                               const size_t y_offset, const size_t y_inc, cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Geru(static_cast<clblast::Layout>(layout), m, n, float2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset,
                      x_inc, y_buffer, y_offset, y_inc, a_buffer, a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZgeru(const CLBlastLayout layout, const size_t m, const size_t n, const cl_double2 alpha,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_mem y_buffer,
                               const size_t y_offset, const size_t y_inc, cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Geru(static_cast<clblast::Layout>(layout), m, n, double2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset,
                      x_inc, y_buffer, y_offset, y_inc, a_buffer, a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// GERC
CLBlastStatusCode CLBlastCgerc(const CLBlastLayout layout, const size_t m, const size_t n, const cl_float2 alpha,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_mem y_buffer,
                               const size_t y_offset, const size_t y_inc, cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gerc(static_cast<clblast::Layout>(layout), m, n, float2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset,
                      x_inc, y_buffer, y_offset, y_inc, a_buffer, a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZgerc(const CLBlastLayout layout, const size_t m, const size_t n, const cl_double2 alpha,
                               const cl_mem x_buffer, const size_t x_offset, const size_t x_inc, const cl_mem y_buffer,
                               const size_t y_offset, const size_t y_inc, cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gerc(static_cast<clblast::Layout>(layout), m, n, double2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset,
                      x_inc, y_buffer, y_offset, y_inc, a_buffer, a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// HER
CLBlastStatusCode CLBlastCher(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                              const float alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                              cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_command_queue* queue,
                              cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Her(static_cast<clblast::Layout>(layout),
                                                       static_cast<clblast::Triangle>(triangle), n, alpha, x_buffer,
                                                       x_offset, x_inc, a_buffer, a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZher(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                              const double alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                              cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_command_queue* queue,
                              cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Her(static_cast<clblast::Layout>(layout),
                                                       static_cast<clblast::Triangle>(triangle), n, alpha, x_buffer,
                                                       x_offset, x_inc, a_buffer, a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// HPR
CLBlastStatusCode CLBlastChpr(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                              const float alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                              cl_mem ap_buffer, const size_t ap_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Hpr(static_cast<clblast::Layout>(layout),
                                                       static_cast<clblast::Triangle>(triangle), n, alpha, x_buffer,
                                                       x_offset, x_inc, ap_buffer, ap_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZhpr(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                              const double alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                              cl_mem ap_buffer, const size_t ap_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Hpr(static_cast<clblast::Layout>(layout),
                                                       static_cast<clblast::Triangle>(triangle), n, alpha, x_buffer,
                                                       x_offset, x_inc, ap_buffer, ap_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// HER2
CLBlastStatusCode CLBlastCher2(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const cl_float2 alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_mem a_buffer,
                               const size_t a_offset, const size_t a_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Her2(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n,
                      float2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, a_buffer,
                      a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZher2(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const cl_double2 alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_mem a_buffer,
                               const size_t a_offset, const size_t a_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Her2(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n,
                      double2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, a_buffer,
                      a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// HPR2
CLBlastStatusCode CLBlastChpr2(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const cl_float2 alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_mem ap_buffer,
                               const size_t ap_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Hpr2(static_cast<clblast::Layout>(layout),
                                                        static_cast<clblast::Triangle>(triangle), n,
                                                        float2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset, x_inc,
                                                        y_buffer, y_offset, y_inc, ap_buffer, ap_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZhpr2(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const cl_double2 alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_mem ap_buffer,
                               const size_t ap_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Hpr2(static_cast<clblast::Layout>(layout),
                                                        static_cast<clblast::Triangle>(triangle), n,
                                                        double2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset, x_inc,
                                                        y_buffer, y_offset, y_inc, ap_buffer, ap_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SYR
CLBlastStatusCode CLBlastSsyr(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                              const float alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                              cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_command_queue* queue,
                              cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Syr(static_cast<clblast::Layout>(layout),
                                                       static_cast<clblast::Triangle>(triangle), n, alpha, x_buffer,
                                                       x_offset, x_inc, a_buffer, a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDsyr(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                              const double alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                              cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_command_queue* queue,
                              cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Syr(static_cast<clblast::Layout>(layout),
                                                       static_cast<clblast::Triangle>(triangle), n, alpha, x_buffer,
                                                       x_offset, x_inc, a_buffer, a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHsyr(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                              const cl_half alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                              cl_mem a_buffer, const size_t a_offset, const size_t a_ld, cl_command_queue* queue,
                              cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Syr(static_cast<clblast::Layout>(layout),
                                                       static_cast<clblast::Triangle>(triangle), n, alpha, x_buffer,
                                                       x_offset, x_inc, a_buffer, a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SPR
CLBlastStatusCode CLBlastSspr(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                              const float alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                              cl_mem ap_buffer, const size_t ap_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Spr(static_cast<clblast::Layout>(layout),
                                                       static_cast<clblast::Triangle>(triangle), n, alpha, x_buffer,
                                                       x_offset, x_inc, ap_buffer, ap_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDspr(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                              const double alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                              cl_mem ap_buffer, const size_t ap_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Spr(static_cast<clblast::Layout>(layout),
                                                       static_cast<clblast::Triangle>(triangle), n, alpha, x_buffer,
                                                       x_offset, x_inc, ap_buffer, ap_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHspr(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                              const cl_half alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                              cl_mem ap_buffer, const size_t ap_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Spr(static_cast<clblast::Layout>(layout),
                                                       static_cast<clblast::Triangle>(triangle), n, alpha, x_buffer,
                                                       x_offset, x_inc, ap_buffer, ap_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SYR2
CLBlastStatusCode CLBlastSsyr2(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const float alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_mem a_buffer,
                               const size_t a_offset, const size_t a_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Syr2(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, alpha,
                      x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, a_buffer, a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDsyr2(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const double alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_mem a_buffer,
                               const size_t a_offset, const size_t a_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Syr2(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, alpha,
                      x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, a_buffer, a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHsyr2(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const cl_half alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_mem a_buffer,
                               const size_t a_offset, const size_t a_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Syr2(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, alpha,
                      x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, a_buffer, a_offset, a_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SPR2
CLBlastStatusCode CLBlastSspr2(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const float alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_mem ap_buffer,
                               const size_t ap_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Spr2(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, alpha,
                      x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, ap_buffer, ap_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDspr2(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const double alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_mem ap_buffer,
                               const size_t ap_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Spr2(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, alpha,
                      x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, ap_buffer, ap_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHspr2(const CLBlastLayout layout, const CLBlastTriangle triangle, const size_t n,
                               const cl_half alpha, const cl_mem x_buffer, const size_t x_offset, const size_t x_inc,
                               const cl_mem y_buffer, const size_t y_offset, const size_t y_inc, cl_mem ap_buffer,
                               const size_t ap_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Spr2(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle), n, alpha,
                      x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc, ap_buffer, ap_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// =================================================================================================
// BLAS level-3 (matrix-matrix) routines
// =================================================================================================

// GEMM
CLBlastStatusCode CLBlastSgemm(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                               const CLBlastTranspose b_transpose, const size_t m, const size_t n, const size_t k,
                               const float alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const float beta,
                               cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gemm(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Transpose>(b_transpose), m, n, k, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDgemm(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                               const CLBlastTranspose b_transpose, const size_t m, const size_t n, const size_t k,
                               const double alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const double beta,
                               cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gemm(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Transpose>(b_transpose), m, n, k, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCgemm(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                               const CLBlastTranspose b_transpose, const size_t m, const size_t n, const size_t k,
                               const cl_float2 alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const cl_float2 beta,
                               cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Gemm(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, float2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld,
        b_buffer, b_offset, b_ld, float2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZgemm(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                               const CLBlastTranspose b_transpose, const size_t m, const size_t n, const size_t k,
                               const cl_double2 alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const cl_double2 beta,
                               cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Gemm(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, double2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset,
        a_ld, b_buffer, b_offset, b_ld, double2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHgemm(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                               const CLBlastTranspose b_transpose, const size_t m, const size_t n, const size_t k,
                               const cl_half alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const cl_half beta,
                               cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gemm(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Transpose>(b_transpose), m, n, k, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SYMM
CLBlastStatusCode CLBlastSsymm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const size_t m, const size_t n, const float alpha, const cl_mem a_buffer,
                               const size_t a_offset, const size_t a_ld, const cl_mem b_buffer, const size_t b_offset,
                               const size_t b_ld, const float beta, cl_mem c_buffer, const size_t c_offset,
                               const size_t c_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Symm(static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
                      static_cast<clblast::Triangle>(triangle), m, n, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDsymm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const size_t m, const size_t n, const double alpha, const cl_mem a_buffer,
                               const size_t a_offset, const size_t a_ld, const cl_mem b_buffer, const size_t b_offset,
                               const size_t b_ld, const double beta, cl_mem c_buffer, const size_t c_offset,
                               const size_t c_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Symm(static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
                      static_cast<clblast::Triangle>(triangle), m, n, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCsymm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const size_t m, const size_t n, const cl_float2 alpha, const cl_mem a_buffer,
                               const size_t a_offset, const size_t a_ld, const cl_mem b_buffer, const size_t b_offset,
                               const size_t b_ld, const cl_float2 beta, cl_mem c_buffer, const size_t c_offset,
                               const size_t c_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Symm(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
        static_cast<clblast::Triangle>(triangle), m, n, float2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld,
        b_buffer, b_offset, b_ld, float2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZsymm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const size_t m, const size_t n, const cl_double2 alpha, const cl_mem a_buffer,
                               const size_t a_offset, const size_t a_ld, const cl_mem b_buffer, const size_t b_offset,
                               const size_t b_ld, const cl_double2 beta, cl_mem c_buffer, const size_t c_offset,
                               const size_t c_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Symm(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
        static_cast<clblast::Triangle>(triangle), m, n, double2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld,
        b_buffer, b_offset, b_ld, double2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHsymm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const size_t m, const size_t n, const cl_half alpha, const cl_mem a_buffer,
                               const size_t a_offset, const size_t a_ld, const cl_mem b_buffer, const size_t b_offset,
                               const size_t b_ld, const cl_half beta, cl_mem c_buffer, const size_t c_offset,
                               const size_t c_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Symm(static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
                      static_cast<clblast::Triangle>(triangle), m, n, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// HEMM
CLBlastStatusCode CLBlastChemm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const size_t m, const size_t n, const cl_float2 alpha, const cl_mem a_buffer,
                               const size_t a_offset, const size_t a_ld, const cl_mem b_buffer, const size_t b_offset,
                               const size_t b_ld, const cl_float2 beta, cl_mem c_buffer, const size_t c_offset,
                               const size_t c_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Hemm(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
        static_cast<clblast::Triangle>(triangle), m, n, float2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld,
        b_buffer, b_offset, b_ld, float2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZhemm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const size_t m, const size_t n, const cl_double2 alpha, const cl_mem a_buffer,
                               const size_t a_offset, const size_t a_ld, const cl_mem b_buffer, const size_t b_offset,
                               const size_t b_ld, const cl_double2 beta, cl_mem c_buffer, const size_t c_offset,
                               const size_t c_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Hemm(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
        static_cast<clblast::Triangle>(triangle), m, n, double2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld,
        b_buffer, b_offset, b_ld, double2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SYRK
CLBlastStatusCode CLBlastSsyrk(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const size_t n, const size_t k, const float alpha,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const float beta,
                               cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Syrk(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                      static_cast<clblast::Transpose>(a_transpose), n, k, alpha, a_buffer, a_offset, a_ld, beta,
                      c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDsyrk(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const size_t n, const size_t k, const double alpha,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const double beta,
                               cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Syrk(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                      static_cast<clblast::Transpose>(a_transpose), n, k, alpha, a_buffer, a_offset, a_ld, beta,
                      c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCsyrk(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const size_t n, const size_t k,
                               const cl_float2 alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               const cl_float2 beta, cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Syrk(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                      static_cast<clblast::Transpose>(a_transpose), n, k, float2{alpha.s[0], alpha.s[1]}, a_buffer,
                      a_offset, a_ld, float2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZsyrk(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const size_t n, const size_t k,
                               const cl_double2 alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                               const cl_double2 beta, cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Syrk(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                      static_cast<clblast::Transpose>(a_transpose), n, k, double2{alpha.s[0], alpha.s[1]}, a_buffer,
                      a_offset, a_ld, double2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHsyrk(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const size_t n, const size_t k, const cl_half alpha,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const cl_half beta,
                               cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Syrk(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                      static_cast<clblast::Transpose>(a_transpose), n, k, alpha, a_buffer, a_offset, a_ld, beta,
                      c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// HERK
CLBlastStatusCode CLBlastCherk(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const size_t n, const size_t k, const float alpha,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const float beta,
                               cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Herk(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                      static_cast<clblast::Transpose>(a_transpose), n, k, alpha, a_buffer, a_offset, a_ld, beta,
                      c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZherk(const CLBlastLayout layout, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const size_t n, const size_t k, const double alpha,
                               const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const double beta,
                               cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                               cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Herk(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                      static_cast<clblast::Transpose>(a_transpose), n, k, alpha, a_buffer, a_offset, a_ld, beta,
                      c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// SYR2K
CLBlastStatusCode CLBlastSsyr2k(const CLBlastLayout layout, const CLBlastTriangle triangle,
                                const CLBlastTranspose ab_transpose, const size_t n, const size_t k, const float alpha,
                                const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const cl_mem b_buffer,
                                const size_t b_offset, const size_t b_ld, const float beta, cl_mem c_buffer,
                                const size_t c_offset, const size_t c_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Syr2k(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                       static_cast<clblast::Transpose>(ab_transpose), n, k, alpha, a_buffer, a_offset, a_ld, b_buffer,
                       b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDsyr2k(const CLBlastLayout layout, const CLBlastTriangle triangle,
                                const CLBlastTranspose ab_transpose, const size_t n, const size_t k, const double alpha,
                                const cl_mem a_buffer, const size_t a_offset, const size_t a_ld, const cl_mem b_buffer,
                                const size_t b_offset, const size_t b_ld, const double beta, cl_mem c_buffer,
                                const size_t c_offset, const size_t c_ld, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Syr2k(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                       static_cast<clblast::Transpose>(ab_transpose), n, k, alpha, a_buffer, a_offset, a_ld, b_buffer,
                       b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCsyr2k(const CLBlastLayout layout, const CLBlastTriangle triangle,
                                const CLBlastTranspose ab_transpose, const size_t n, const size_t k,
                                const cl_float2 alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                                const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const cl_float2 beta,
                                cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                                cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Syr2k(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
        static_cast<clblast::Transpose>(ab_transpose), n, k, float2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld,
        b_buffer, b_offset, b_ld, float2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZsyr2k(const CLBlastLayout layout, const CLBlastTriangle triangle,
                                const CLBlastTranspose ab_transpose, const size_t n, const size_t k,
                                const cl_double2 alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                                const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const cl_double2 beta,
                                cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                                cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Syr2k(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
        static_cast<clblast::Transpose>(ab_transpose), n, k, double2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld,
        b_buffer, b_offset, b_ld, double2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHsyr2k(const CLBlastLayout layout, const CLBlastTriangle triangle,
                                const CLBlastTranspose ab_transpose, const size_t n, const size_t k,
                                const cl_half alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                                const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const cl_half beta,
                                cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                                cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Syr2k(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                       static_cast<clblast::Transpose>(ab_transpose), n, k, alpha, a_buffer, a_offset, a_ld, b_buffer,
                       b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// HER2K
CLBlastStatusCode CLBlastCher2k(const CLBlastLayout layout, const CLBlastTriangle triangle,
                                const CLBlastTranspose ab_transpose, const size_t n, const size_t k,
                                const cl_float2 alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                                const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const float beta,
                                cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                                cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Her2k(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                       static_cast<clblast::Transpose>(ab_transpose), n, k, float2{alpha.s[0], alpha.s[1]}, a_buffer,
                       a_offset, a_ld, b_buffer, b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZher2k(const CLBlastLayout layout, const CLBlastTriangle triangle,
                                const CLBlastTranspose ab_transpose, const size_t n, const size_t k,
                                const cl_double2 alpha, const cl_mem a_buffer, const size_t a_offset, const size_t a_ld,
                                const cl_mem b_buffer, const size_t b_offset, const size_t b_ld, const double beta,
                                cl_mem c_buffer, const size_t c_offset, const size_t c_ld, cl_command_queue* queue,
                                cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Her2k(static_cast<clblast::Layout>(layout), static_cast<clblast::Triangle>(triangle),
                       static_cast<clblast::Transpose>(ab_transpose), n, k, double2{alpha.s[0], alpha.s[1]}, a_buffer,
                       a_offset, a_ld, b_buffer, b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// TRMM
CLBlastStatusCode CLBlastStrmm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t m,
                               const size_t n, const float alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trmm(static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
                      static_cast<clblast::Triangle>(triangle), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Diagonal>(diagonal), m, n, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDtrmm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t m,
                               const size_t n, const double alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trmm(static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
                      static_cast<clblast::Triangle>(triangle), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Diagonal>(diagonal), m, n, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCtrmm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t m,
                               const size_t n, const cl_float2 alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trmm(static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
                      static_cast<clblast::Triangle>(triangle), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Diagonal>(diagonal), m, n, float2{alpha.s[0], alpha.s[1]}, a_buffer,
                      a_offset, a_ld, b_buffer, b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZtrmm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t m,
                               const size_t n, const cl_double2 alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trmm(static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
                      static_cast<clblast::Triangle>(triangle), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Diagonal>(diagonal), m, n, double2{alpha.s[0], alpha.s[1]}, a_buffer,
                      a_offset, a_ld, b_buffer, b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHtrmm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t m,
                               const size_t n, const cl_half alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trmm(static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
                      static_cast<clblast::Triangle>(triangle), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Diagonal>(diagonal), m, n, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// TRSM
CLBlastStatusCode CLBlastStrsm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t m,
                               const size_t n, const float alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trsm(static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
                      static_cast<clblast::Triangle>(triangle), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Diagonal>(diagonal), m, n, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDtrsm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t m,
                               const size_t n, const double alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trsm(static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
                      static_cast<clblast::Triangle>(triangle), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Diagonal>(diagonal), m, n, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCtrsm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t m,
                               const size_t n, const cl_float2 alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trsm(static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
                      static_cast<clblast::Triangle>(triangle), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Diagonal>(diagonal), m, n, float2{alpha.s[0], alpha.s[1]}, a_buffer,
                      a_offset, a_ld, b_buffer, b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZtrsm(const CLBlastLayout layout, const CLBlastSide side, const CLBlastTriangle triangle,
                               const CLBlastTranspose a_transpose, const CLBlastDiagonal diagonal, const size_t m,
                               const size_t n, const cl_double2 alpha, const cl_mem a_buffer, const size_t a_offset,
                               const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                               cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Trsm(static_cast<clblast::Layout>(layout), static_cast<clblast::Side>(side),
                      static_cast<clblast::Triangle>(triangle), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Diagonal>(diagonal), m, n, double2{alpha.s[0], alpha.s[1]}, a_buffer,
                      a_offset, a_ld, b_buffer, b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// =================================================================================================
// Extra non-BLAS routines (level-X)
// =================================================================================================

// HAD
CLBlastStatusCode CLBlastShad(const size_t n, const float alpha, const cl_mem x_buffer, const size_t x_offset,
                              const size_t x_inc, const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                              const float beta, cl_mem z_buffer, const size_t z_offset, const size_t z_inc,
                              cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Had(n, alpha, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc,
                                                       beta, z_buffer, z_offset, z_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDhad(const size_t n, const double alpha, const cl_mem x_buffer, const size_t x_offset,
                              const size_t x_inc, const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                              const double beta, cl_mem z_buffer, const size_t z_offset, const size_t z_inc,
                              cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Had(n, alpha, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc,
                                                       beta, z_buffer, z_offset, z_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastChad(const size_t n, const cl_float2 alpha, const cl_mem x_buffer, const size_t x_offset,
                              const size_t x_inc, const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                              const cl_float2 beta, cl_mem z_buffer, const size_t z_offset, const size_t z_inc,
                              cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Had(n, float2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset, x_inc,
                                                       y_buffer, y_offset, y_inc, float2{beta.s[0], beta.s[1]},
                                                       z_buffer, z_offset, z_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZhad(const size_t n, const cl_double2 alpha, const cl_mem x_buffer, const size_t x_offset,
                              const size_t x_inc, const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                              const cl_double2 beta, cl_mem z_buffer, const size_t z_offset, const size_t z_inc,
                              cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Had(n, double2{alpha.s[0], alpha.s[1]}, x_buffer, x_offset, x_inc,
                                                       y_buffer, y_offset, y_inc, double2{beta.s[0], beta.s[1]},
                                                       z_buffer, z_offset, z_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHhad(const size_t n, const cl_half alpha, const cl_mem x_buffer, const size_t x_offset,
                              const size_t x_inc, const cl_mem y_buffer, const size_t y_offset, const size_t y_inc,
                              const cl_half beta, cl_mem z_buffer, const size_t z_offset, const size_t z_inc,
                              cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Had(n, alpha, x_buffer, x_offset, x_inc, y_buffer, y_offset, y_inc,
                                                       beta, z_buffer, z_offset, z_inc, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// OMATCOPY
CLBlastStatusCode CLBlastSomatcopy(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                                   const size_t n, const float alpha, const cl_mem a_buffer, const size_t a_offset,
                                   const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                                   cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Omatcopy(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n,
                          alpha, a_buffer, a_offset, a_ld, b_buffer, b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDomatcopy(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                                   const size_t n, const double alpha, const cl_mem a_buffer, const size_t a_offset,
                                   const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                                   cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Omatcopy(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n,
                          alpha, a_buffer, a_offset, a_ld, b_buffer, b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastComatcopy(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                                   const size_t n, const cl_float2 alpha, const cl_mem a_buffer, const size_t a_offset,
                                   const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                                   cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Omatcopy(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n,
        float2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld, b_buffer, b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZomatcopy(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                                   const size_t n, const cl_double2 alpha, const cl_mem a_buffer, const size_t a_offset,
                                   const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                                   cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Omatcopy(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n,
        double2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld, b_buffer, b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHomatcopy(const CLBlastLayout layout, const CLBlastTranspose a_transpose, const size_t m,
                                   const size_t n, const cl_half alpha, const cl_mem a_buffer, const size_t a_offset,
                                   const size_t a_ld, cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                                   cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Omatcopy(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose), m, n,
                          alpha, a_buffer, a_offset, a_ld, b_buffer, b_offset, b_ld, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// IM2COL
CLBlastStatusCode CLBlastSim2col(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                 const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                 const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                 const size_t dilation_h, const size_t dilation_w, const cl_mem im_buffer,
                                 const size_t im_offset, cl_mem col_buffer, const size_t col_offset,
                                 cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Im2col<float>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, im_buffer, im_offset, col_buffer, col_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDim2col(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                 const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                 const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                 const size_t dilation_h, const size_t dilation_w, const cl_mem im_buffer,
                                 const size_t im_offset, cl_mem col_buffer, const size_t col_offset,
                                 cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Im2col<double>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, im_buffer, im_offset, col_buffer, col_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCim2col(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                 const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                 const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                 const size_t dilation_h, const size_t dilation_w, const cl_mem im_buffer,
                                 const size_t im_offset, cl_mem col_buffer, const size_t col_offset,
                                 cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Im2col<float2>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, im_buffer, im_offset, col_buffer, col_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZim2col(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                 const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                 const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                 const size_t dilation_h, const size_t dilation_w, const cl_mem im_buffer,
                                 const size_t im_offset, cl_mem col_buffer, const size_t col_offset,
                                 cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Im2col<double2>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, im_buffer, im_offset, col_buffer, col_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHim2col(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                 const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                 const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                 const size_t dilation_h, const size_t dilation_w, const cl_mem im_buffer,
                                 const size_t im_offset, cl_mem col_buffer, const size_t col_offset,
                                 cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Im2col<half>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, im_buffer, im_offset, col_buffer, col_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// COL2IM
CLBlastStatusCode CLBlastScol2im(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                 const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                 const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                 const size_t dilation_h, const size_t dilation_w, const cl_mem col_buffer,
                                 const size_t col_offset, cl_mem im_buffer, const size_t im_offset,
                                 cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Col2im<float>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, col_buffer, col_offset, im_buffer, im_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDcol2im(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                 const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                 const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                 const size_t dilation_h, const size_t dilation_w, const cl_mem col_buffer,
                                 const size_t col_offset, cl_mem im_buffer, const size_t im_offset,
                                 cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Col2im<double>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, col_buffer, col_offset, im_buffer, im_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCcol2im(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                 const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                 const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                 const size_t dilation_h, const size_t dilation_w, const cl_mem col_buffer,
                                 const size_t col_offset, cl_mem im_buffer, const size_t im_offset,
                                 cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Col2im<float2>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, col_buffer, col_offset, im_buffer, im_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZcol2im(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                 const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                 const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                 const size_t dilation_h, const size_t dilation_w, const cl_mem col_buffer,
                                 const size_t col_offset, cl_mem im_buffer, const size_t im_offset,
                                 cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Col2im<double2>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, col_buffer, col_offset, im_buffer, im_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHcol2im(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                 const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                 const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                 const size_t dilation_h, const size_t dilation_w, const cl_mem col_buffer,
                                 const size_t col_offset, cl_mem im_buffer, const size_t im_offset,
                                 cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Col2im<half>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, col_buffer, col_offset, im_buffer, im_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// CONVGEMM
CLBlastStatusCode CLBlastSconvgemm(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                   const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                   const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                   const size_t dilation_h, const size_t dilation_w, const size_t num_kernels,
                                   const size_t batch_count, const cl_mem im_buffer, const size_t im_offset,
                                   const cl_mem kernel_buffer, const size_t kernel_offset, cl_mem result_buffer,
                                   const size_t result_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Convgemm<float>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, num_kernels, batch_count, im_buffer, im_offset, kernel_buffer,
        kernel_offset, result_buffer, result_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDconvgemm(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                   const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                   const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                   const size_t dilation_h, const size_t dilation_w, const size_t num_kernels,
                                   const size_t batch_count, const cl_mem im_buffer, const size_t im_offset,
                                   const cl_mem kernel_buffer, const size_t kernel_offset, cl_mem result_buffer,
                                   const size_t result_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Convgemm<double>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, num_kernels, batch_count, im_buffer, im_offset, kernel_buffer,
        kernel_offset, result_buffer, result_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHconvgemm(const CLBlastKernelMode kernel_mode, const size_t channels, const size_t height,
                                   const size_t width, const size_t kernel_h, const size_t kernel_w, const size_t pad_h,
                                   const size_t pad_w, const size_t stride_h, const size_t stride_w,
                                   const size_t dilation_h, const size_t dilation_w, const size_t num_kernels,
                                   const size_t batch_count, const cl_mem im_buffer, const size_t im_offset,
                                   const cl_mem kernel_buffer, const size_t kernel_offset, cl_mem result_buffer,
                                   const size_t result_offset, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Convgemm<half>(
        static_cast<clblast::KernelMode>(kernel_mode), channels, height, width, kernel_h, kernel_w, pad_h, pad_w,
        stride_h, stride_w, dilation_h, dilation_w, num_kernels, batch_count, im_buffer, im_offset, kernel_buffer,
        kernel_offset, result_buffer, result_offset, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// AXPY
CLBlastStatusCode CLBlastSaxpyBatched(const size_t n, const float* alphas, const cl_mem x_buffer,
                                      const size_t* x_offsets, const size_t x_inc, cl_mem y_buffer,
                                      const size_t* y_offsets, const size_t y_inc, const size_t batch_count,
                                      cl_command_queue* queue, cl_event* event) {
  auto alphas_cpp = std::vector<float>();
  for (auto batch = size_t{0}; batch < batch_count; ++batch) {
    alphas_cpp.push_back(alphas[batch]);
  }
  try {
    return static_cast<CLBlastStatusCode>(clblast::AxpyBatched(n, alphas_cpp.data(), x_buffer, x_offsets, x_inc,
                                                               y_buffer, y_offsets, y_inc, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDaxpyBatched(const size_t n, const double* alphas, const cl_mem x_buffer,
                                      const size_t* x_offsets, const size_t x_inc, cl_mem y_buffer,
                                      const size_t* y_offsets, const size_t y_inc, const size_t batch_count,
                                      cl_command_queue* queue, cl_event* event) {
  auto alphas_cpp = std::vector<double>();
  for (auto batch = size_t{0}; batch < batch_count; ++batch) {
    alphas_cpp.push_back(alphas[batch]);
  }
  try {
    return static_cast<CLBlastStatusCode>(clblast::AxpyBatched(n, alphas_cpp.data(), x_buffer, x_offsets, x_inc,
                                                               y_buffer, y_offsets, y_inc, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCaxpyBatched(const size_t n, const cl_float2* alphas, const cl_mem x_buffer,
                                      const size_t* x_offsets, const size_t x_inc, cl_mem y_buffer,
                                      const size_t* y_offsets, const size_t y_inc, const size_t batch_count,
                                      cl_command_queue* queue, cl_event* event) {
  auto alphas_cpp = std::vector<float2>();
  for (auto batch = size_t{0}; batch < batch_count; ++batch) {
    alphas_cpp.push_back(float2{alphas[batch].s[0], alphas[batch].s[1]});
  }
  try {
    return static_cast<CLBlastStatusCode>(clblast::AxpyBatched(n, alphas_cpp.data(), x_buffer, x_offsets, x_inc,
                                                               y_buffer, y_offsets, y_inc, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZaxpyBatched(const size_t n, const cl_double2* alphas, const cl_mem x_buffer,
                                      const size_t* x_offsets, const size_t x_inc, cl_mem y_buffer,
                                      const size_t* y_offsets, const size_t y_inc, const size_t batch_count,
                                      cl_command_queue* queue, cl_event* event) {
  auto alphas_cpp = std::vector<double2>();
  for (auto batch = size_t{0}; batch < batch_count; ++batch) {
    alphas_cpp.push_back(double2{alphas[batch].s[0], alphas[batch].s[1]});
  }
  try {
    return static_cast<CLBlastStatusCode>(clblast::AxpyBatched(n, alphas_cpp.data(), x_buffer, x_offsets, x_inc,
                                                               y_buffer, y_offsets, y_inc, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHaxpyBatched(const size_t n, const cl_half* alphas, const cl_mem x_buffer,
                                      const size_t* x_offsets, const size_t x_inc, cl_mem y_buffer,
                                      const size_t* y_offsets, const size_t y_inc, const size_t batch_count,
                                      cl_command_queue* queue, cl_event* event) {
  auto alphas_cpp = std::vector<half>();
  for (auto batch = size_t{0}; batch < batch_count; ++batch) {
    alphas_cpp.push_back(alphas[batch]);
  }
  try {
    return static_cast<CLBlastStatusCode>(clblast::AxpyBatched(n, alphas_cpp.data(), x_buffer, x_offsets, x_inc,
                                                               y_buffer, y_offsets, y_inc, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// GEMM
CLBlastStatusCode CLBlastSgemmBatched(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                      const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                      const size_t k, const float* alphas, const cl_mem a_buffer,
                                      const size_t* a_offsets, const size_t a_ld, const cl_mem b_buffer,
                                      const size_t* b_offsets, const size_t b_ld, const float* betas, cl_mem c_buffer,
                                      const size_t* c_offsets, const size_t c_ld, const size_t batch_count,
                                      cl_command_queue* queue, cl_event* event) {
  auto alphas_cpp = std::vector<float>();
  auto betas_cpp = std::vector<float>();
  for (auto batch = size_t{0}; batch < batch_count; ++batch) {
    alphas_cpp.push_back(alphas[batch]);
    betas_cpp.push_back(betas[batch]);
  }
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmBatched(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, alphas_cpp.data(), a_buffer, a_offsets, a_ld, b_buffer,
        b_offsets, b_ld, betas_cpp.data(), c_buffer, c_offsets, c_ld, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDgemmBatched(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                      const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                      const size_t k, const double* alphas, const cl_mem a_buffer,
                                      const size_t* a_offsets, const size_t a_ld, const cl_mem b_buffer,
                                      const size_t* b_offsets, const size_t b_ld, const double* betas, cl_mem c_buffer,
                                      const size_t* c_offsets, const size_t c_ld, const size_t batch_count,
                                      cl_command_queue* queue, cl_event* event) {
  auto alphas_cpp = std::vector<double>();
  auto betas_cpp = std::vector<double>();
  for (auto batch = size_t{0}; batch < batch_count; ++batch) {
    alphas_cpp.push_back(alphas[batch]);
    betas_cpp.push_back(betas[batch]);
  }
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmBatched(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, alphas_cpp.data(), a_buffer, a_offsets, a_ld, b_buffer,
        b_offsets, b_ld, betas_cpp.data(), c_buffer, c_offsets, c_ld, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCgemmBatched(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                      const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                      const size_t k, const cl_float2* alphas, const cl_mem a_buffer,
                                      const size_t* a_offsets, const size_t a_ld, const cl_mem b_buffer,
                                      const size_t* b_offsets, const size_t b_ld, const cl_float2* betas,
                                      cl_mem c_buffer, const size_t* c_offsets, const size_t c_ld,
                                      const size_t batch_count, cl_command_queue* queue, cl_event* event) {
  auto alphas_cpp = std::vector<float2>();
  auto betas_cpp = std::vector<float2>();
  for (auto batch = size_t{0}; batch < batch_count; ++batch) {
    alphas_cpp.push_back(float2{alphas[batch].s[0], alphas[batch].s[1]});
    betas_cpp.push_back(float2{betas[batch].s[0], betas[batch].s[1]});
  }
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmBatched(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, alphas_cpp.data(), a_buffer, a_offsets, a_ld, b_buffer,
        b_offsets, b_ld, betas_cpp.data(), c_buffer, c_offsets, c_ld, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZgemmBatched(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                      const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                      const size_t k, const cl_double2* alphas, const cl_mem a_buffer,
                                      const size_t* a_offsets, const size_t a_ld, const cl_mem b_buffer,
                                      const size_t* b_offsets, const size_t b_ld, const cl_double2* betas,
                                      cl_mem c_buffer, const size_t* c_offsets, const size_t c_ld,
                                      const size_t batch_count, cl_command_queue* queue, cl_event* event) {
  auto alphas_cpp = std::vector<double2>();
  auto betas_cpp = std::vector<double2>();
  for (auto batch = size_t{0}; batch < batch_count; ++batch) {
    alphas_cpp.push_back(double2{alphas[batch].s[0], alphas[batch].s[1]});
    betas_cpp.push_back(double2{betas[batch].s[0], betas[batch].s[1]});
  }
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmBatched(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, alphas_cpp.data(), a_buffer, a_offsets, a_ld, b_buffer,
        b_offsets, b_ld, betas_cpp.data(), c_buffer, c_offsets, c_ld, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHgemmBatched(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                      const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                      const size_t k, const cl_half* alphas, const cl_mem a_buffer,
                                      const size_t* a_offsets, const size_t a_ld, const cl_mem b_buffer,
                                      const size_t* b_offsets, const size_t b_ld, const cl_half* betas, cl_mem c_buffer,
                                      const size_t* c_offsets, const size_t c_ld, const size_t batch_count,
                                      cl_command_queue* queue, cl_event* event) {
  auto alphas_cpp = std::vector<half>();
  auto betas_cpp = std::vector<half>();
  for (auto batch = size_t{0}; batch < batch_count; ++batch) {
    alphas_cpp.push_back(alphas[batch]);
    betas_cpp.push_back(betas[batch]);
  }
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmBatched(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, alphas_cpp.data(), a_buffer, a_offsets, a_ld, b_buffer,
        b_offsets, b_ld, betas_cpp.data(), c_buffer, c_offsets, c_ld, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// GEMM
CLBlastStatusCode CLBlastSgemmStridedBatched(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const float alpha, const cl_mem a_buffer,
                                             const size_t a_offset, const size_t a_ld, const size_t a_stride,
                                             const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                                             const size_t b_stride, const float beta, cl_mem c_buffer,
                                             const size_t c_offset, const size_t c_ld, const size_t c_stride,
                                             const size_t batch_count, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmStridedBatched(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, alpha, a_buffer, a_offset, a_ld, a_stride, b_buffer,
        b_offset, b_ld, b_stride, beta, c_buffer, c_offset, c_ld, c_stride, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDgemmStridedBatched(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const double alpha, const cl_mem a_buffer,
                                             const size_t a_offset, const size_t a_ld, const size_t a_stride,
                                             const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                                             const size_t b_stride, const double beta, cl_mem c_buffer,
                                             const size_t c_offset, const size_t c_ld, const size_t c_stride,
                                             const size_t batch_count, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmStridedBatched(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, alpha, a_buffer, a_offset, a_ld, a_stride, b_buffer,
        b_offset, b_ld, b_stride, beta, c_buffer, c_offset, c_ld, c_stride, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCgemmStridedBatched(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const cl_float2 alpha, const cl_mem a_buffer,
                                             const size_t a_offset, const size_t a_ld, const size_t a_stride,
                                             const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                                             const size_t b_stride, const cl_float2 beta, cl_mem c_buffer,
                                             const size_t c_offset, const size_t c_ld, const size_t c_stride,
                                             const size_t batch_count, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmStridedBatched(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, float2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld,
        a_stride, b_buffer, b_offset, b_ld, b_stride, float2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld, c_stride,
        batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZgemmStridedBatched(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const cl_double2 alpha, const cl_mem a_buffer,
                                             const size_t a_offset, const size_t a_ld, const size_t a_stride,
                                             const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                                             const size_t b_stride, const cl_double2 beta, cl_mem c_buffer,
                                             const size_t c_offset, const size_t c_ld, const size_t c_stride,
                                             const size_t batch_count, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmStridedBatched(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, double2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset,
        a_ld, a_stride, b_buffer, b_offset, b_ld, b_stride, double2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld,
        c_stride, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHgemmStridedBatched(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const cl_half alpha, const cl_mem a_buffer,
                                             const size_t a_offset, const size_t a_ld, const size_t a_stride,
                                             const cl_mem b_buffer, const size_t b_offset, const size_t b_ld,
                                             const size_t b_stride, const cl_half beta, cl_mem c_buffer,
                                             const size_t c_offset, const size_t c_ld, const size_t c_stride,
                                             const size_t batch_count, cl_command_queue* queue, cl_event* event) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmStridedBatched(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, alpha, a_buffer, a_offset, a_ld, a_stride, b_buffer,
        b_offset, b_ld, b_stride, beta, c_buffer, c_offset, c_ld, c_stride, batch_count, queue, event));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// =================================================================================================

// GEMM with temporary buffer (optional, for advanced users)
CLBlastStatusCode CLBlastSgemmWithTempBuffer(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const float alpha, const cl_mem a_buffer,
                                             const size_t a_offset, const size_t a_ld, const cl_mem b_buffer,
                                             const size_t b_offset, const size_t b_ld, const float beta,
                                             cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
                                             cl_command_queue* queue, cl_event* event, cl_mem temp_buffer) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gemm(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Transpose>(b_transpose), m, n, k, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event, temp_buffer));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastDgemmWithTempBuffer(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const double alpha, const cl_mem a_buffer,
                                             const size_t a_offset, const size_t a_ld, const cl_mem b_buffer,
                                             const size_t b_offset, const size_t b_ld, const double beta,
                                             cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
                                             cl_command_queue* queue, cl_event* event, cl_mem temp_buffer) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gemm(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Transpose>(b_transpose), m, n, k, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event, temp_buffer));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastCgemmWithTempBuffer(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const cl_float2 alpha, const cl_mem a_buffer,
                                             const size_t a_offset, const size_t a_ld, const cl_mem b_buffer,
                                             const size_t b_offset, const size_t b_ld, const cl_float2 beta,
                                             cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
                                             cl_command_queue* queue, cl_event* event, cl_mem temp_buffer) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::Gemm(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, float2{alpha.s[0], alpha.s[1]}, a_buffer, a_offset, a_ld,
        b_buffer, b_offset, b_ld, float2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld, queue, event, temp_buffer));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastZgemmWithTempBuffer(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const cl_double2 alpha, const cl_mem a_buffer,
                                             const size_t a_offset, const size_t a_ld, const cl_mem b_buffer,
                                             const size_t b_offset, const size_t b_ld, const cl_double2 beta,
                                             cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
                                             cl_command_queue* queue, cl_event* event, cl_mem temp_buffer) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gemm(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Transpose>(b_transpose), m, n, k, double2{alpha.s[0], alpha.s[1]}, a_buffer,
                      a_offset, a_ld, b_buffer, b_offset, b_ld, double2{beta.s[0], beta.s[1]}, c_buffer, c_offset, c_ld,
                      queue, event, temp_buffer));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}
CLBlastStatusCode CLBlastHgemmWithTempBuffer(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const cl_half alpha, const cl_mem a_buffer,
                                             const size_t a_offset, const size_t a_ld, const cl_mem b_buffer,
                                             const size_t b_offset, const size_t b_ld, const cl_half beta,
                                             cl_mem c_buffer, const size_t c_offset, const size_t c_ld,
                                             cl_command_queue* queue, cl_event* event, cl_mem temp_buffer) {
  try {
    return static_cast<CLBlastStatusCode>(
        clblast::Gemm(static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
                      static_cast<clblast::Transpose>(b_transpose), m, n, k, alpha, a_buffer, a_offset, a_ld, b_buffer,
                      b_offset, b_ld, beta, c_buffer, c_offset, c_ld, queue, event, temp_buffer));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// =================================================================================================

// GEMM get temporary buffer size
CLBlastStatusCode CLBlastSGemmTempBufferSize(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const size_t a_offset, const size_t a_ld,
                                             const size_t b_offset, const size_t b_ld, const size_t c_offset,
                                             const size_t c_ld, cl_command_queue* queue, size_t* temp_buffer_size) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmTempBufferSize<float>(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, a_offset, a_ld, b_offset, b_ld, c_offset, c_ld, queue,
        *temp_buffer_size));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

CLBlastStatusCode CLBlastDGemmTempBufferSize(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const size_t a_offset, const size_t a_ld,
                                             const size_t b_offset, const size_t b_ld, const size_t c_offset,
                                             const size_t c_ld, cl_command_queue* queue, size_t* temp_buffer_size) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmTempBufferSize<double>(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, a_offset, a_ld, b_offset, b_ld, c_offset, c_ld, queue,
        *temp_buffer_size));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

CLBlastStatusCode CLBlastCGemmTempBufferSize(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const size_t a_offset, const size_t a_ld,
                                             const size_t b_offset, const size_t b_ld, const size_t c_offset,
                                             const size_t c_ld, cl_command_queue* queue, size_t* temp_buffer_size) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmTempBufferSize<float2>(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, a_offset, a_ld, b_offset, b_ld, c_offset, c_ld, queue,
        *temp_buffer_size));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

CLBlastStatusCode CLBlastZGemmTempBufferSize(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const size_t a_offset, const size_t a_ld,
                                             const size_t b_offset, const size_t b_ld, const size_t c_offset,
                                             const size_t c_ld, cl_command_queue* queue, size_t* temp_buffer_size) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmTempBufferSize<double2>(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, a_offset, a_ld, b_offset, b_ld, c_offset, c_ld, queue,
        *temp_buffer_size));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

CLBlastStatusCode CLBlastHGemmTempBufferSize(const CLBlastLayout layout, const CLBlastTranspose a_transpose,
                                             const CLBlastTranspose b_transpose, const size_t m, const size_t n,
                                             const size_t k, const size_t a_offset, const size_t a_ld,
                                             const size_t b_offset, const size_t b_ld, const size_t c_offset,
                                             const size_t c_ld, cl_command_queue* queue, size_t* temp_buffer_size) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::GemmTempBufferSize<half>(
        static_cast<clblast::Layout>(layout), static_cast<clblast::Transpose>(a_transpose),
        static_cast<clblast::Transpose>(b_transpose), m, n, k, a_offset, a_ld, b_offset, b_ld, c_offset, c_ld, queue,
        *temp_buffer_size));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// =================================================================================================

// Clears the cache of stored binaries
CLBlastStatusCode CLBlastClearCache() {
  try {
    return static_cast<CLBlastStatusCode>(clblast::ClearCache());
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// Fills the cache with binaries for a specific device
CLBlastStatusCode CLBlastFillCache(const cl_device_id device) {
  try {
    return static_cast<CLBlastStatusCode>(clblast::FillCache(device));
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// =================================================================================================

// Overrides the tuning parameters for this device-precision-kernel combination
CLBlastStatusCode PUBLIC_API CLBlastOverrideParameters(const cl_device_id device, const char* kernel_name,
                                                       const CLBlastPrecision precision, const size_t num_parameters,
                                                       const char** parameters_names, const size_t* parameters_values) {
  try {
    const auto kernel_name_cpp = std::string(kernel_name);
    const auto precision_cpp = static_cast<clblast::Precision>(precision);
    auto parameters = std::unordered_map<std::string, size_t>();
    for (auto i = size_t{0}; i < num_parameters; ++i) {
      const auto parameter_name = std::string(parameters_names[i]);
      const auto parameter_value = parameters_values[i];
      parameters[parameter_name] = parameter_value;
    }
    const auto status = clblast::OverrideParameters(device, kernel_name_cpp, precision_cpp, parameters);
    return static_cast<CLBlastStatusCode>(status);
  } catch (...) {
    return static_cast<CLBlastStatusCode>(clblast::DispatchExceptionForC());
  }
}

// =================================================================================================
