Remove operators API

The operators API generated by the script is no longer used
and could be removed from the project.

Signed-off-by: Dmitrii Agibov <dmitrii.agibov@arm.com>
Change-Id: Ia611b069463b3aded7d6546987c2323674184673

10 files changed, 4 insertions, 4708 deletions

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 2c72a26..67e60da 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,4 +1,4 @@
-# Copyright (c) 2021-2023 Arm Limited.
+# Copyright (c) 2021-2024 Arm Limited.
 # SPDX-License-Identifier: Apache-2.0
 
 # See https://pre-commit.com for more information
@@ -38,12 +38,3 @@ repos:
         entry: clang-format
         types: ["c++"]
         args: ["-i"]
-
--   repo: local
-    hooks:
-    -   id: check-operator-api
-        name: check-operator-api
-        language: system
-        entry: python3 scripts/operator_api/generate_api.py
-        pass_filenames: false
-        always_run: true
diff --git a/reference_model/CMakeLists.txt b/reference_model/CMakeLists.txt
index 5c40ce5..538c50b 100644
--- a/reference_model/CMakeLists.txt
+++ b/reference_model/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required (VERSION 3.4)
 
-# Copyright (c) 2020-2023, ARM Limited.
+# Copyright (c) 2020-2024, ARM Limited.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.
@@ -68,7 +68,6 @@ set(CXX_SOURCE
     src/graph_node.cc
     src/model_runner_impl.cc
     src/model_runner.cc
-    src/operators.cc
     src/subgraph_traverser.cc
     src/tensor.cc
     src/generate/generate_dot_product_states.cc
diff --git a/reference_model/include/operators.h b/reference_model/include/operators.h
deleted file mode 100644
index 62e6db1..0000000
--- a/reference_model/include/operators.h
+++ /dev/null
@@ -1,412 +0,0 @@
-
-// Copyright (c) 2022-2023, ARM Limited.
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//         http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-
-// THIS FILE IS GENERATED. DO NOT EDIT!
-// See scripts/operator_api/generate_api.py
-
-#ifndef OPERATORS_H_
-#define OPERATORS_H_
-
-#include "func_config.h"
-#include "func_debug.h"
-#include "types.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-    struct func_ctx_t
-    {
-        func_config_t func_config = func_config_t{};
-        func_debug_t func_debug   = func_debug_t{};
-    };
-
-    tosa_status_t tosa_run_argmax(tosa_tensor_t client_input,
-                                  const int32_t client_axis,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_avg_pool2d(tosa_tensor_t client_input,
-                                      const int32_t client_kernel[2],
-                                      const int32_t client_stride[2],
-                                      const int32_t client_pad[4],
-                                      const tosa_acc_size_t client_acc_size,
-                                      const int32_t client_input_zp,
-                                      const int32_t client_output_zp,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_conv2d(tosa_tensor_t client_input,
-                                  tosa_tensor_t client_weight,
-                                  tosa_tensor_t client_bias,
-                                  const int32_t client_pad[4],
-                                  const int32_t client_stride[2],
-                                  const int32_t client_dilation[2],
-                                  const int32_t client_input_zp,
-                                  const int32_t client_weight_zp,
-                                  const bool client_local_bound,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_conv3d(tosa_tensor_t client_input,
-                                  tosa_tensor_t client_weight,
-                                  tosa_tensor_t client_bias,
-                                  const int32_t client_pad[6],
-                                  const int32_t client_stride[3],
-                                  const int32_t client_dilation[3],
-                                  const int32_t client_input_zp,
-                                  const int32_t client_weight_zp,
-                                  const bool client_local_bound,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_depthwise_conv2d(tosa_tensor_t client_input,
-                                            tosa_tensor_t client_weight,
-                                            tosa_tensor_t client_bias,
-                                            const int32_t client_pad[4],
-                                            const int32_t client_stride[2],
-                                            const int32_t client_dilation[2],
-                                            const int32_t client_input_zp,
-                                            const int32_t client_weight_zp,
-                                            const bool client_local_bound,
-                                            tosa_tensor_t client_output,
-                                            const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_fft2d(tosa_tensor_t client_input_real,
-                                 tosa_tensor_t client_input_imag,
-                                 const bool client_inverse,
-                                 tosa_tensor_t client_output_real,
-                                 const bool client_local_bound,
-                                 tosa_tensor_t client_output_imag,
-                                 const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_fully_connected(tosa_tensor_t client_input,
-                                           tosa_tensor_t client_weight,
-                                           tosa_tensor_t client_bias,
-                                           const int32_t client_input_zp,
-                                           const int32_t client_weight_zp,
-                                           tosa_tensor_t client_output,
-                                           const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_matmul(tosa_tensor_t client_a,
-                                  tosa_tensor_t client_b,
-                                  const int32_t client_a_zp,
-                                  const int32_t client_b_zp,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_max_pool2d(tosa_tensor_t client_input,
-                                      const int32_t client_kernel[2],
-                                      const int32_t client_stride[2],
-                                      const int32_t client_pad[4],
-                                      const int32_t client_input_zp,
-                                      const int32_t client_output_zp,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_rfft2d(tosa_tensor_t client_input,
-                                  tosa_tensor_t client_output_real,
-                                  const bool client_local_bound,
-                                  tosa_tensor_t client_output_imag,
-                                  const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_transpose_conv2d(tosa_tensor_t client_input,
-                                            tosa_tensor_t client_weight,
-                                            tosa_tensor_t client_bias,
-                                            const int32_t client_out_pad[4],
-                                            const int32_t client_stride[2],
-                                            const int32_t client_out_shape[4],
-                                            const int32_t client_input_zp,
-                                            const int32_t client_weight_zp,
-                                            const bool client_local_bound,
-                                            tosa_tensor_t client_output,
-                                            const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_clamp(tosa_tensor_t client_input,
-                                 const int32_t client_min_int,
-                                 const int32_t client_max_int,
-                                 const float client_min_fp,
-                                 const float client_max_fp,
-                                 tosa_tensor_t client_output,
-                                 const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_erf(tosa_tensor_t client_input, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_sigmoid(tosa_tensor_t client_input, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_tanh(tosa_tensor_t client_input, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_add(tosa_tensor_t client_input1,
-                               tosa_tensor_t client_input2,
-                               tosa_tensor_t client_output,
-                               const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_arithmetic_right_shift(tosa_tensor_t client_input1,
-                                                  tosa_tensor_t client_input2,
-                                                  const bool client_round,
-                                                  tosa_tensor_t client_output,
-                                                  const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_bitwise_and(tosa_tensor_t client_input1,
-                                       tosa_tensor_t client_input2,
-                                       tosa_tensor_t client_output,
-                                       const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_bitwise_or(tosa_tensor_t client_input1,
-                                      tosa_tensor_t client_input2,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_bitwise_xor(tosa_tensor_t client_input1,
-                                       tosa_tensor_t client_input2,
-                                       tosa_tensor_t client_output,
-                                       const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_intdiv(tosa_tensor_t client_input1,
-                                  tosa_tensor_t client_input2,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_logical_and(tosa_tensor_t client_input1,
-                                       tosa_tensor_t client_input2,
-                                       tosa_tensor_t client_output,
-                                       const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_logical_left_shift(tosa_tensor_t client_input1,
-                                              tosa_tensor_t client_input2,
-                                              tosa_tensor_t client_output,
-                                              const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_logical_right_shift(tosa_tensor_t client_input1,
-                                               tosa_tensor_t client_input2,
-                                               tosa_tensor_t client_output,
-                                               const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_logical_or(tosa_tensor_t client_input1,
-                                      tosa_tensor_t client_input2,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_logical_xor(tosa_tensor_t client_input1,
-                                       tosa_tensor_t client_input2,
-                                       tosa_tensor_t client_output,
-                                       const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_maximum(tosa_tensor_t client_input1,
-                                   tosa_tensor_t client_input2,
-                                   tosa_tensor_t client_output,
-                                   const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_minimum(tosa_tensor_t client_input1,
-                                   tosa_tensor_t client_input2,
-                                   tosa_tensor_t client_output,
-                                   const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_mul(tosa_tensor_t client_input1,
-                               tosa_tensor_t client_input2,
-                               const int32_t client_shift,
-                               tosa_tensor_t client_output,
-                               const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_pow(tosa_tensor_t client_input1,
-                               tosa_tensor_t client_input2,
-                               tosa_tensor_t client_output,
-                               const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_sub(tosa_tensor_t client_input1,
-                               tosa_tensor_t client_input2,
-                               tosa_tensor_t client_output,
-                               const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_table(tosa_tensor_t client_input,
-                                 const int32_t client_table_len,
-                                 const int16_t client_table[],
-                                 tosa_tensor_t client_output,
-                                 const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_abs(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t
-        tosa_run_bitwise_not(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_ceil(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_clz(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_exp(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_floor(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_log(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t
-        tosa_run_logical_not(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_negate(tosa_tensor_t client_input1,
-                                  const int32_t client_input1_zp,
-                                  const int32_t client_output_zp,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx);
-
-    tosa_status_t
-        tosa_run_reciprocal(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_rsqrt(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_select(tosa_tensor_t client_input1,
-                                  tosa_tensor_t client_input2,
-                                  tosa_tensor_t client_input3,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_equal(tosa_tensor_t client_input1,
-                                 tosa_tensor_t client_input2,
-                                 tosa_tensor_t client_output,
-                                 const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_greater(tosa_tensor_t client_input1,
-                                   tosa_tensor_t client_input2,
-                                   tosa_tensor_t client_output,
-                                   const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_greater_equal(tosa_tensor_t client_input1,
-                                         tosa_tensor_t client_input2,
-                                         tosa_tensor_t client_output,
-                                         const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_reduce_all(tosa_tensor_t client_input,
-                                      const int32_t client_axis,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_reduce_any(tosa_tensor_t client_input,
-                                      const int32_t client_axis,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_reduce_max(tosa_tensor_t client_input,
-                                      const int32_t client_axis,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_reduce_min(tosa_tensor_t client_input,
-                                      const int32_t client_axis,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_reduce_product(tosa_tensor_t client_input,
-                                          const int32_t client_axis,
-                                          tosa_tensor_t client_output,
-                                          const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_reduce_sum(tosa_tensor_t client_input,
-                                      const int32_t client_axis,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_concat(const tosa_tensor_list_t client_input1,
-                                  const int32_t client_axis,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_pad(tosa_tensor_t client_input1,
-                               tosa_tensor_t client_padding,
-                               const int32_t client_pad_const_int,
-                               const float client_pad_const_fp,
-                               tosa_tensor_t client_output,
-                               const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_dim(tosa_tensor_t client_input1,
-                               const int32_t client_axis,
-                               tosa_tensor_t client_output,
-                               const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_reshape(tosa_tensor_t client_input1,
-                                   tosa_tensor_t client_shape,
-                                   tosa_tensor_t client_output,
-                                   const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_reverse(tosa_tensor_t client_input,
-                                   const int32_t client_axis,
-                                   tosa_tensor_t client_output,
-                                   const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_slice(tosa_tensor_t client_input1,
-                                 const int32_t client_start_len,
-                                 const int32_t client_start[],
-                                 const int32_t client_size_len,
-                                 const int32_t client_size[],
-                                 tosa_tensor_t client_output,
-                                 const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_tile(tosa_tensor_t client_input1,
-                                tosa_tensor_t client_multiples,
-                                tosa_tensor_t client_output,
-                                const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_transpose(tosa_tensor_t client_input1,
-                                     const int32_t client_perms_len,
-                                     const int32_t client_perms[],
-                                     tosa_tensor_t client_output,
-                                     const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_gather(tosa_tensor_t client_values,
-                                  tosa_tensor_t client_indices,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_scatter(tosa_tensor_t client_values_in,
-                                   tosa_tensor_t client_indices,
-                                   tosa_tensor_t client_input,
-                                   tosa_tensor_t client_values_out,
-                                   const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_resize(tosa_tensor_t client_input,
-                                  tosa_tensor_t client_scale,
-                                  tosa_tensor_t client_offset,
-                                  tosa_tensor_t client_border,
-                                  const tosa_mode_t client_mode,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_cast(tosa_tensor_t client_input, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-    tosa_status_t tosa_run_rescale(tosa_tensor_t client_input,
-                                   tosa_tensor_t client_output,
-                                   const int32_t client_input_zp,
-                                   const int32_t client_output_zp,
-                                   const int32_t client_multiplier_len,
-                                   const int32_t client_multiplier[],
-                                   const int32_t client_shift_len,
-                                   const int32_t client_shift[],
-                                   const bool client_scale32,
-                                   const bool client_double_round,
-                                   const bool client_input_unsigned,
-                                   const bool client_output_unsigned,
-                                   const bool client_per_channel,
-                                   const func_ctx_t& func_ctx);
-
-    tosa_status_t
-        tosa_run_identity(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif    // OPERATORS_H_
\ No newline at end of file
diff --git a/reference_model/include/types.h b/reference_model/include/types.h
index 2be884d..15ee40c 100644
--- a/reference_model/include/types.h
+++ b/reference_model/include/types.h
@@ -1,5 +1,5 @@
 
-// Copyright (c) 2022-2023, ARM Limited.
+// Copyright (c) 2022-2024, ARM Limited.
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -24,23 +24,6 @@ extern "C"
 {
 #endif /* __cplusplus */
 
-    // Note status needs to be aligned with graph_status
-    enum tosa_status_t
-    {
-        tosa_status_valid         = 0,
-        tosa_status_unpredictable = 1,
-        tosa_status_error         = 2
-    };
-
-    enum tosa_mode_t
-    {
-        tosa_mode_unknown  = 0,
-        tosa_mode_nearest  = 1,
-        tosa_mode_bilinear = 2,
-        tosa_mode_min      = 3,
-        tosa_mode_max      = 4
-    };
-
     enum tosa_datatype_t
     {
         tosa_datatype_bf16_t   = 0,
@@ -58,13 +41,6 @@ extern "C"
         tosa_datatype_fp64_t   = 99
     };
 
-    enum tosa_acc_size_t
-    {
-        tosa_acc_size_int32_t = 0,
-        tosa_acc_size_fp16_t  = 1,
-        tosa_acc_size_fp32_t  = 2
-    };
-
     struct tosa_tensor_t
     {
         const char* name;
diff --git a/reference_model/src/operators.cc b/reference_model/src/operators.cc
deleted file mode 100644
index 1c97455..0000000
--- a/reference_model/src/operators.cc
+++ /dev/null
@@ -1,2892 +0,0 @@
-
-// Copyright (c) 2022-2023, ARM Limited.
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//         http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-
-// THIS FILE IS GENERATED. DO NOT EDIT!
-// See scripts/operator_api/generate_api.py
-
-#include "operators.h"
-#include "model_runner_impl.h"
-#include "ops/op_factory.h"
-
-#define TOSA_PROPAGATE_ERROR(status)                                                                                   \
-    do                                                                                                                 \
-    {                                                                                                                  \
-        if (status != 0)                                                                                               \
-        {                                                                                                              \
-            return status;                                                                                             \
-        }                                                                                                              \
-    } while (false)
-
-#define TOSA_RETURN_ON_ERROR(status)                                                                                   \
-    do                                                                                                                 \
-    {                                                                                                                  \
-        if (status != 0)                                                                                               \
-        {                                                                                                              \
-            return tosa_status_error;                                                                                  \
-        }                                                                                                              \
-    } while (false)
-
-#define TOSA_RETURN_ON_GRAPH_STATUS_ERROR(status)                                                                      \
-    do                                                                                                                 \
-    {                                                                                                                  \
-        if (status != GraphStatus::TOSA_VALID)                                                                         \
-        {                                                                                                              \
-            auto ustatus = static_cast<std::underlying_type_t<GraphStatus>>(status);                                   \
-            return static_cast<tosa_status_t>(ustatus);                                                                \
-        }                                                                                                              \
-    } while (false)
-
-namespace
-{
-
-tosa::DType translate_client_datatype(tosa_datatype_t type)
-{
-    switch (type)
-    {
-        case tosa_datatype_bf16_t:
-            return tosa::DType::DType_BF16;
-        case tosa_datatype_bool_t:
-            return tosa::DType::DType_BOOL;
-        case tosa_datatype_fp16_t:
-            return tosa::DType::DType_FP16;
-        case tosa_datatype_fp32_t:
-            return tosa::DType::DType_FP32;
-        case tosa_datatype_int16_t:
-            return tosa::DType::DType_INT16;
-        case tosa_datatype_int32_t:
-            return tosa::DType::DType_INT32;
-        case tosa_datatype_int48_t:
-            return tosa::DType::DType_INT48;
-        case tosa_datatype_int4_t:
-            return tosa::DType::DType_INT4;
-        case tosa_datatype_int8_t:
-            return tosa::DType::DType_INT8;
-        case tosa_datatype_uint16_t:
-            return tosa::DType::DType_UINT16;
-        case tosa_datatype_uint8_t:
-            return tosa::DType::DType_UINT8;
-        case tosa_datatype_shape_t:
-            return tosa::DType::DType_SHAPE;
-        default:
-            return tosa::DType::DType_UNKNOWN;
-    }
-};
-
-using TosaTensorInfo = std::pair<tosa::TosaSerializationTensor*, tosa_tensor_t*>;
-
-tosa::TosaSerializationTensor* translate_client_tensor(tosa_tensor_t& tensor, const std::string& name)
-{
-    std::vector<int32_t> shape(tensor.shape, tensor.shape + tensor.num_dims);
-    return new tosa::TosaSerializationTensor(name, shape, translate_client_datatype(tensor.data_type), {});
-}
-
-void addTensor(std::vector<TosaTensorInfo>& tensors, tosa_tensor_t& tensor, std::string tensorName)
-{
-    auto tensorDescr = translate_client_tensor(tensor, tensorName);
-    tensors.push_back(std::make_pair(tensorDescr, &tensor));
-}
-
-int setInputTensors(TosaReference::ModelRunnerImpl& runner, std::vector<TosaTensorInfo>& inputTensors)
-{
-    for (const auto& [tensorDescr, tensorData] : inputTensors)
-    {
-        auto status = runner.setInput(tensorDescr->GetName(), tensorData->data, tensorData->size);
-        TOSA_PROPAGATE_ERROR(status);
-    }
-
-    return 0;
-}
-
-int getOutputTensors(TosaReference::ModelRunnerImpl& runner, std::vector<TosaTensorInfo>& outputTensors)
-{
-    for (const auto& [tensorDescr, tensorData] : outputTensors)
-    {
-        auto status = runner.getOutput(tensorDescr->GetName(), tensorData->data, tensorData->size);
-        TOSA_PROPAGATE_ERROR(status);
-    }
-
-    return 0;
-}
-
-std::vector<std::string> getTensorNames(std::vector<TosaTensorInfo>& tensors)
-{
-    std::vector<std::string> tensorNames;
-    const auto mapping = [](const TosaTensorInfo& info) { return info.first->GetName(); };
-
-    std::transform(tensors.cbegin(), tensors.cend(), std::back_inserter(tensorNames), mapping);
-    return tensorNames;
-}
-
-std::vector<TosaSerializationTensor*> allTensors(std::vector<TosaTensorInfo>& inputTensors,
-                                                 std::vector<TosaTensorInfo>& outputTensors)
-{
-    std::vector<TosaSerializationTensor*> result;
-    const auto mapping = [](const TosaTensorInfo& info) { return info.first; };
-
-    std::transform(inputTensors.cbegin(), inputTensors.cend(), std::back_inserter(result), mapping);
-    std::transform(outputTensors.cbegin(), outputTensors.cend(), std::back_inserter(result), mapping);
-
-    return result;
-}
-
-tosa::ResizeMode translate_client_tosa_mode(tosa_mode_t mode)
-{
-    switch (mode)
-    {
-        case tosa_mode_nearest:
-            return tosa::ResizeMode_NEAREST;
-        case tosa_mode_max:
-        case tosa_mode_bilinear:
-            return tosa::ResizeMode_BILINEAR;
-        default:
-            return tosa::ResizeMode_UNKNOWN;
-    }
-}
-
-tosa::DType translate_client_acc_size(tosa_acc_size_t acc_size)
-{
-    switch (acc_size)
-    {
-        case tosa_acc_size_int32_t:
-            return tosa::DType::DType_INT32;
-        case tosa_acc_size_fp16_t:
-            return tosa::DType::DType_FP16;
-        case tosa_acc_size_fp32_t:
-            return tosa::DType::DType_FP32;
-        default:
-            return tosa::DType::DType_UNKNOWN;
-    }
-}
-
-}    // namespace
-
-extern "C"
-{
-
-    tosa_status_t tosa_run_argmax(tosa_tensor_t client_input,
-                                  const int32_t client_axis,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaAxisAttribute attr(client_axis);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_ARGMAX, tosa::Attribute::Attribute_AxisAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("argmax", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_avg_pool2d(tosa_tensor_t client_input,
-                                      const int32_t client_kernel[2],
-                                      const int32_t client_stride[2],
-                                      const int32_t client_pad[4],
-                                      const tosa_acc_size_t client_acc_size,
-                                      const int32_t client_input_zp,
-                                      const int32_t client_output_zp,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);
-        const std::vector<int32_t> kernel(&client_kernel[0], &client_kernel[2]);
-        const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);
-        const tosa::DType accum_dtype = translate_client_acc_size(client_acc_size);
-        TosaPoolAttribute attr(pad, kernel, stride, client_input_zp, client_output_zp, accum_dtype);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_AVG_POOL2D, tosa::Attribute::Attribute_PoolAttribute,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("avg_pool2d", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_conv2d(tosa_tensor_t client_input,
-                                  tosa_tensor_t client_weight,
-                                  tosa_tensor_t client_bias,
-                                  const int32_t client_pad[4],
-                                  const int32_t client_stride[2],
-                                  const int32_t client_dilation[2],
-                                  const int32_t client_input_zp,
-                                  const int32_t client_weight_zp,
-                                  const bool client_local_bound,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);
-        const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);
-        const std::vector<int32_t> dilation(&client_dilation[0], &client_dilation[2]);
-        TosaConvAttribute attr(pad, stride, dilation, client_input_zp, client_weight_zp, client_local_bound);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-        addTensor(inputTensors, client_weight, "weight");
-        addTensor(inputTensors, client_bias, "bias");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_CONV2D, tosa::Attribute::Attribute_ConvAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("conv2d", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_conv3d(tosa_tensor_t client_input,
-                                  tosa_tensor_t client_weight,
-                                  tosa_tensor_t client_bias,
-                                  const int32_t client_pad[6],
-                                  const int32_t client_stride[3],
-                                  const int32_t client_dilation[3],
-                                  const int32_t client_input_zp,
-                                  const int32_t client_weight_zp,
-                                  const bool client_local_bound,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        const std::vector<int32_t> pad(&client_pad[0], &client_pad[6]);
-        const std::vector<int32_t> stride(&client_stride[0], &client_stride[3]);
-        const std::vector<int32_t> dilation(&client_dilation[0], &client_dilation[3]);
-        TosaConvAttribute attr(pad, stride, dilation, client_input_zp, client_weight_zp, client_local_bound);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-        addTensor(inputTensors, client_weight, "weight");
-        addTensor(inputTensors, client_bias, "bias");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_CONV3D, tosa::Attribute::Attribute_ConvAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("conv3d", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_depthwise_conv2d(tosa_tensor_t client_input,
-                                            tosa_tensor_t client_weight,
-                                            tosa_tensor_t client_bias,
-                                            const int32_t client_pad[4],
-                                            const int32_t client_stride[2],
-                                            const int32_t client_dilation[2],
-                                            const int32_t client_input_zp,
-                                            const int32_t client_weight_zp,
-                                            const bool client_local_bound,
-                                            tosa_tensor_t client_output,
-                                            const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);
-        const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);
-        const std::vector<int32_t> dilation(&client_dilation[0], &client_dilation[2]);
-        TosaConvAttribute attr(pad, stride, dilation, client_input_zp, client_weight_zp, client_local_bound);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-        addTensor(inputTensors, client_weight, "weight");
-        addTensor(inputTensors, client_bias, "bias");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_DEPTHWISE_CONV2D, tosa::Attribute::Attribute_ConvAttribute,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("depthwise_conv2d", "main", { op },
-                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
-                                                op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_fft2d(tosa_tensor_t client_input_real,
-                                 tosa_tensor_t client_input_imag,
-                                 const bool client_inverse,
-                                 tosa_tensor_t client_output_real,
-                                 const bool client_local_bound,
-                                 tosa_tensor_t client_output_imag,
-                                 const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaFFTAttribute attr(client_inverse, client_local_bound);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input_real, "input_real");
-        addTensor(inputTensors, client_input_imag, "input_imag");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output_real, "output_real");
-        addTensor(outputTensors, client_output_imag, "output_imag");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_FFT2D, tosa::Attribute::Attribute_FFTAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("fft2d", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_fully_connected(tosa_tensor_t client_input,
-                                           tosa_tensor_t client_weight,
-                                           tosa_tensor_t client_bias,
-                                           const int32_t client_input_zp,
-                                           const int32_t client_weight_zp,
-                                           tosa_tensor_t client_output,
-                                           const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaFullyConnectedAttribute attr(client_input_zp, client_weight_zp);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-        addTensor(inputTensors, client_weight, "weight");
-        addTensor(inputTensors, client_bias, "bias");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_FULLY_CONNECTED,
-                                                      tosa::Attribute::Attribute_FullyConnectedAttribute, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("fully_connected", "main", { op },
-                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
-                                                op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_matmul(tosa_tensor_t client_a,
-                                  tosa_tensor_t client_b,
-                                  const int32_t client_a_zp,
-                                  const int32_t client_b_zp,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaMatMulAttribute attr(client_a_zp, client_b_zp);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_a, "a");
-        addTensor(inputTensors, client_b, "b");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_MATMUL, tosa::Attribute::Attribute_MatMulAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("matmul", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_max_pool2d(tosa_tensor_t client_input,
-                                      const int32_t client_kernel[2],
-                                      const int32_t client_stride[2],
-                                      const int32_t client_pad[4],
-                                      const int32_t client_input_zp,
-                                      const int32_t client_output_zp,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);
-        const std::vector<int32_t> kernel(&client_kernel[0], &client_kernel[2]);
-        const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);
-        const tosa::DType accum_dtype = tosa::DType::DType_FP32;
-        TosaPoolAttribute attr(pad, kernel, stride, client_input_zp, client_output_zp, accum_dtype);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_MAX_POOL2D, tosa::Attribute::Attribute_PoolAttribute,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("max_pool2d", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_rfft2d(tosa_tensor_t client_input,
-                                  tosa_tensor_t client_output_real,
-                                  const bool client_local_bound,
-                                  tosa_tensor_t client_output_imag,
-                                  const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaRFFTAttribute attr(client_local_bound);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output_real, "output_real");
-        addTensor(outputTensors, client_output_imag, "output_imag");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_RFFT2D, tosa::Attribute::Attribute_RFFTAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("rfft2d", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_transpose_conv2d(tosa_tensor_t client_input,
-                                            tosa_tensor_t client_weight,
-                                            tosa_tensor_t client_bias,
-                                            const int32_t client_out_pad[4],
-                                            const int32_t client_stride[2],
-                                            const int32_t client_out_shape[4],
-                                            const int32_t client_input_zp,
-                                            const int32_t client_weight_zp,
-                                            const bool client_local_bound,
-                                            tosa_tensor_t client_output,
-                                            const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        const std::vector<int32_t> out_pad(&client_out_pad[0], &client_out_pad[4]);
-        const std::vector<int32_t> stride(&client_stride[0], &client_stride[2]);
-        const std::vector<int32_t> out_shape(&client_out_shape[0], &client_out_shape[4]);
-        TosaTransposeConvAttribute attr(out_pad, stride, out_shape, client_input_zp, client_weight_zp,
-                                        client_local_bound);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-        addTensor(inputTensors, client_weight, "weight");
-        addTensor(inputTensors, client_bias, "bias");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TRANSPOSE_CONV2D,
-                                                      tosa::Attribute::Attribute_TransposeConvAttribute, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("transpose_conv2d", "main", { op },
-                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
-                                                op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_clamp(tosa_tensor_t client_input,
-                                 const int32_t client_min_int,
-                                 const int32_t client_max_int,
-                                 const float client_min_fp,
-                                 const float client_max_fp,
-                                 tosa_tensor_t client_output,
-                                 const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaClampAttribute attr(client_min_int, client_max_int, client_min_fp, client_max_fp);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_CLAMP, tosa::Attribute::Attribute_ClampAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("clamp", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_erf(tosa_tensor_t client_input, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ERF, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("erf", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_sigmoid(tosa_tensor_t client_input, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SIGMOID, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("sigmoid", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_tanh(tosa_tensor_t client_input, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TANH, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("tanh", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_add(tosa_tensor_t client_input1,
-                               tosa_tensor_t client_input2,
-                               tosa_tensor_t client_output,
-                               const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ADD, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("add", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_arithmetic_right_shift(tosa_tensor_t client_input1,
-                                                  tosa_tensor_t client_input2,
-                                                  const bool client_round,
-                                                  tosa_tensor_t client_output,
-                                                  const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaArithmeticRightShiftAttribute attr(client_round);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ARITHMETIC_RIGHT_SHIFT,
-                                                      tosa::Attribute::Attribute_ArithmeticRightShiftAttribute, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("arithmetic_right_shift", "main", { op },
-                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
-                                                op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_bitwise_and(tosa_tensor_t client_input1,
-                                       tosa_tensor_t client_input2,
-                                       tosa_tensor_t client_output,
-                                       const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_AND, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("bitwise_and", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_bitwise_or(tosa_tensor_t client_input1,
-                                      tosa_tensor_t client_input2,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_OR, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("bitwise_or", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_bitwise_xor(tosa_tensor_t client_input1,
-                                       tosa_tensor_t client_input2,
-                                       tosa_tensor_t client_output,
-                                       const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_XOR, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("bitwise_xor", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_intdiv(tosa_tensor_t client_input1,
-                                  tosa_tensor_t client_input2,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_INTDIV, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("intdiv", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_logical_and(tosa_tensor_t client_input1,
-                                       tosa_tensor_t client_input2,
-                                       tosa_tensor_t client_output,
-                                       const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_AND, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("logical_and", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_logical_left_shift(tosa_tensor_t client_input1,
-                                              tosa_tensor_t client_input2,
-                                              tosa_tensor_t client_output,
-                                              const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_LEFT_SHIFT, tosa::Attribute::Attribute_NONE, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("logical_left_shift", "main", { op },
-                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
-                                                op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_logical_right_shift(tosa_tensor_t client_input1,
-                                               tosa_tensor_t client_input2,
-                                               tosa_tensor_t client_output,
-                                               const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_RIGHT_SHIFT, tosa::Attribute::Attribute_NONE,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("logical_right_shift", "main", { op },
-                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
-                                                op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_logical_or(tosa_tensor_t client_input1,
-                                      tosa_tensor_t client_input2,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_OR, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("logical_or", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_logical_xor(tosa_tensor_t client_input1,
-                                       tosa_tensor_t client_input2,
-                                       tosa_tensor_t client_output,
-                                       const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_XOR, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("logical_xor", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_maximum(tosa_tensor_t client_input1,
-                                   tosa_tensor_t client_input2,
-                                   tosa_tensor_t client_output,
-                                   const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MAXIMUM, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("maximum", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_minimum(tosa_tensor_t client_input1,
-                                   tosa_tensor_t client_input2,
-                                   tosa_tensor_t client_output,
-                                   const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MINIMUM, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("minimum", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_mul(tosa_tensor_t client_input1,
-                               tosa_tensor_t client_input2,
-                               const int32_t client_shift,
-                               tosa_tensor_t client_output,
-                               const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaMulAttribute attr(client_shift);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_MUL, tosa::Attribute::Attribute_MulAttribute, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("mul", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_pow(tosa_tensor_t client_input1,
-                               tosa_tensor_t client_input2,
-                               tosa_tensor_t client_output,
-                               const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_POW, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("pow", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_sub(tosa_tensor_t client_input1,
-                               tosa_tensor_t client_input2,
-                               tosa_tensor_t client_output,
-                               const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SUB, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("sub", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_table(tosa_tensor_t client_input,
-                                 const int32_t client_table_len,
-                                 const int16_t client_table[],
-                                 tosa_tensor_t client_output,
-                                 const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        const std::vector<int16_t> table(&client_table[0], &client_table[0] + client_table_len);
-        TosaTableAttribute attr(table);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_TABLE, tosa::Attribute::Attribute_TableAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("table", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_abs(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_ABS, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("abs", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t
-        tosa_run_bitwise_not(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_BITWISE_NOT, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("bitwise_not", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_ceil(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CEIL, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("ceil", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_clz(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CLZ, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("clz", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_exp(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_EXP, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("exp", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_floor(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_FLOOR, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("floor", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_log(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOG, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("log", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t
-        tosa_run_logical_not(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_LOGICAL_NOT, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("logical_not", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_negate(tosa_tensor_t client_input1,
-                                  const int32_t client_input1_zp,
-                                  const int32_t client_output_zp,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNegateAttribute attr(client_input1_zp, client_output_zp);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_NEGATE, tosa::Attribute::Attribute_NegateAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("negate", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t
-        tosa_run_reciprocal(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RECIPROCAL, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reciprocal", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_rsqrt(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_RSQRT, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("rsqrt", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_select(tosa_tensor_t client_input1,
-                                  tosa_tensor_t client_input2,
-                                  tosa_tensor_t client_input3,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-        addTensor(inputTensors, client_input3, "input3");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SELECT, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("select", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_equal(tosa_tensor_t client_input1,
-                                 tosa_tensor_t client_input2,
-                                 tosa_tensor_t client_output,
-                                 const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_EQUAL, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("equal", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_greater(tosa_tensor_t client_input1,
-                                   tosa_tensor_t client_input2,
-                                   tosa_tensor_t client_output,
-                                   const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_GREATER, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("greater", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_greater_equal(tosa_tensor_t client_input1,
-                                         tosa_tensor_t client_input2,
-                                         tosa_tensor_t client_output,
-                                         const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-        addTensor(inputTensors, client_input2, "input2");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_GREATER_EQUAL, tosa::Attribute::Attribute_NONE, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("greater_equal", "main", { op },
-                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
-                                                op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_reduce_all(tosa_tensor_t client_input,
-                                      const int32_t client_axis,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaAxisAttribute attr(client_axis);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_ALL, tosa::Attribute::Attribute_AxisAttribute,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reduce_all", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_reduce_any(tosa_tensor_t client_input,
-                                      const int32_t client_axis,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaAxisAttribute attr(client_axis);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_ANY, tosa::Attribute::Attribute_AxisAttribute,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reduce_any", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_reduce_max(tosa_tensor_t client_input,
-                                      const int32_t client_axis,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaAxisAttribute attr(client_axis);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_MAX, tosa::Attribute::Attribute_AxisAttribute,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reduce_max", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_reduce_min(tosa_tensor_t client_input,
-                                      const int32_t client_axis,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaAxisAttribute attr(client_axis);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_MIN, tosa::Attribute::Attribute_AxisAttribute,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reduce_min", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_reduce_product(tosa_tensor_t client_input,
-                                          const int32_t client_axis,
-                                          tosa_tensor_t client_output,
-                                          const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaAxisAttribute attr(client_axis);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_PRODUCT, tosa::Attribute::Attribute_AxisAttribute,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reduce_product", "main", { op },
-                                                allTensors(inputTensors, outputTensors), op->GetInputTensorNames(),
-                                                op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_reduce_sum(tosa_tensor_t client_input,
-                                      const int32_t client_axis,
-                                      tosa_tensor_t client_output,
-                                      const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaAxisAttribute attr(client_axis);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_REDUCE_SUM, tosa::Attribute::Attribute_AxisAttribute,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reduce_sum", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_concat(const tosa_tensor_list_t client_input1,
-                                  const int32_t client_axis,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaAxisAttribute attr(client_axis);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        for (int i = 0; i < client_input1.size; i++)
-        {
-            addTensor(inputTensors, client_input1.tensors[i], "input1-" + std::to_string(i));
-        }
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_CONCAT, tosa::Attribute::Attribute_AxisAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("concat", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_pad(tosa_tensor_t client_input1,
-                               tosa_tensor_t client_padding,
-                               const int32_t client_pad_const_int,
-                               const float client_pad_const_fp,
-                               tosa_tensor_t client_output,
-                               const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        std::vector<int32_t> padding;
-        size_t padding_size   = client_padding.size / sizeof(int32_t);
-        int32_t* padding_data = reinterpret_cast<int32_t*>(client_padding.data);
-        padding.assign(padding_data, padding_data + padding_size);
-        TosaPadAttribute attr(padding, client_pad_const_int, client_pad_const_fp);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_PAD, tosa::Attribute::Attribute_PadAttribute, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("pad", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_dim(tosa_tensor_t client_input1,
-                               const int32_t client_axis,
-                               tosa_tensor_t client_output,
-                               const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaAxisAttribute attr(client_axis);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_DIM, tosa::Attribute::Attribute_AxisAttribute, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("dim", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_reshape(tosa_tensor_t client_input1,
-                                   tosa_tensor_t client_shape,
-                                   tosa_tensor_t client_output,
-                                   const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        std::vector<int32_t> shape;
-        size_t shape_size   = client_shape.size / sizeof(int32_t);
-        int32_t* shape_data = reinterpret_cast<int32_t*>(client_shape.data);
-        shape.assign(shape_data, shape_data + shape_size);
-        TosaReshapeAttribute attr(shape);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_RESHAPE, tosa::Attribute::Attribute_ReshapeAttribute,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reshape", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_reverse(tosa_tensor_t client_input,
-                                   const int32_t client_axis,
-                                   tosa_tensor_t client_output,
-                                   const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaAxisAttribute attr(client_axis);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_REVERSE, tosa::Attribute::Attribute_AxisAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("reverse", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_slice(tosa_tensor_t client_input1,
-                                 const int32_t client_start_len,
-                                 const int32_t client_start[],
-                                 const int32_t client_size_len,
-                                 const int32_t client_size[],
-                                 tosa_tensor_t client_output,
-                                 const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        const std::vector<int32_t> start(&client_start[0], &client_start[0] + client_start_len);
-        const std::vector<int32_t> size(&client_size[0], &client_size[0] + client_size_len);
-        TosaSliceAttribute attr(start, size);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_SLICE, tosa::Attribute::Attribute_SliceAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("slice", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_tile(tosa_tensor_t client_input1,
-                                tosa_tensor_t client_multiples,
-                                tosa_tensor_t client_output,
-                                const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        std::vector<int32_t> multiples;
-        size_t multiples_size   = client_multiples.size / sizeof(int32_t);
-        int32_t* multiples_data = reinterpret_cast<int32_t*>(client_multiples.data);
-        multiples.assign(multiples_data, multiples_data + multiples_size);
-        TosaTileAttribute attr(multiples);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_TILE, tosa::Attribute::Attribute_TileAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("tile", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_transpose(tosa_tensor_t client_input1,
-                                     const int32_t client_perms_len,
-                                     const int32_t client_perms[],
-                                     tosa_tensor_t client_output,
-                                     const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        const std::vector<int32_t> perms(&client_perms[0], &client_perms[0] + client_perms_len);
-        TosaTransposeAttribute attr(perms);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_TRANSPOSE, tosa::Attribute::Attribute_TransposeAttribute,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("transpose", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_gather(tosa_tensor_t client_values,
-                                  tosa_tensor_t client_indices,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_values, "values");
-        addTensor(inputTensors, client_indices, "indices");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_GATHER, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("gather", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_scatter(tosa_tensor_t client_values_in,
-                                   tosa_tensor_t client_indices,
-                                   tosa_tensor_t client_input,
-                                   tosa_tensor_t client_values_out,
-                                   const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_values_in, "values_in");
-        addTensor(inputTensors, client_indices, "indices");
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_values_out, "values_out");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SCATTER, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("scatter", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_resize(tosa_tensor_t client_input,
-                                  tosa_tensor_t client_scale,
-                                  tosa_tensor_t client_offset,
-                                  tosa_tensor_t client_border,
-                                  const tosa_mode_t client_mode,
-                                  tosa_tensor_t client_output,
-                                  const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        std::vector<int16_t> scale;
-        size_t scale_size   = client_scale.size / sizeof(int16_t);
-        int16_t* scale_data = reinterpret_cast<int16_t*>(client_scale.data);
-        scale.assign(scale_data, scale_data + scale_size);
-        std::vector<int16_t> offset;
-        size_t offset_size   = client_offset.size / sizeof(int16_t);
-        int16_t* offset_data = reinterpret_cast<int16_t*>(client_offset.data);
-        offset.assign(offset_data, offset_data + offset_size);
-        std::vector<int16_t> border;
-        size_t border_size   = client_border.size / sizeof(int16_t);
-        int16_t* border_data = reinterpret_cast<int16_t*>(client_border.data);
-        border.assign(border_data, border_data + border_size);
-        const ResizeMode mode = translate_client_tosa_mode(client_mode);
-        TosaResizeAttribute attr(scale, offset, border, mode);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_RESIZE, tosa::Attribute::Attribute_ResizeAttribute, &attr,
-                                                getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("resize", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_cast(tosa_tensor_t client_input, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_CAST, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("cast", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_rescale(tosa_tensor_t client_input,
-                                   tosa_tensor_t client_output,
-                                   const int32_t client_input_zp,
-                                   const int32_t client_output_zp,
-                                   const int32_t client_multiplier_len,
-                                   const int32_t client_multiplier[],
-                                   const int32_t client_shift_len,
-                                   const int32_t client_shift[],
-                                   const bool client_scale32,
-                                   const bool client_double_round,
-                                   const bool client_input_unsigned,
-                                   const bool client_output_unsigned,
-                                   const bool client_per_channel,
-                                   const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        const std::vector<int32_t> multiplier(&client_multiplier[0], &client_multiplier[0] + client_multiplier_len);
-        const std::vector<int32_t> shift(&client_shift[0], &client_shift[0] + client_shift_len);
-        TosaRescaleAttribute attr(client_input_zp, client_output_zp, multiplier, shift, client_scale32,
-                                  client_double_round, client_per_channel, client_input_unsigned,
-                                  client_output_unsigned);
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input, "input");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op =
-            new tosa::TosaSerializationOperator(tosa::Op::Op_RESCALE, tosa::Attribute::Attribute_RescaleAttribute,
-                                                &attr, getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("rescale", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t
-        tosa_run_identity(tosa_tensor_t client_input1, tosa_tensor_t client_output, const func_ctx_t& func_ctx)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        addTensor(inputTensors, client_input1, "input1");
-
-        std::vector<TosaTensorInfo> outputTensors;
-        addTensor(outputTensors, client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_IDENTITY, tosa::Attribute::Attribute_NONE, &attr,
-                                                      getTensorNames(inputTensors), getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("identity", "main", { op }, allTensors(inputTensors, outputTensors),
-                                                op->GetInputTensorNames(), op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-
-}    // extern "C"
\ No newline at end of file
diff --git a/reference_model/test/model_runner_tests.cpp b/reference_model/test/model_runner_tests.cpp
index 5292dd8..2aed53f 100644
--- a/reference_model/test/model_runner_tests.cpp
+++ b/reference_model/test/model_runner_tests.cpp
@@ -1,5 +1,5 @@
 
-// Copyright (c) 2022, ARM Limited.
+// Copyright (c) 2022,2024 ARM Limited.
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -19,7 +19,6 @@
 
 #include "general_utils.h"
 #include "model_runner.h"
-#include "operators.h"
 
 #include <numeric>
 
@@ -43,640 +42,6 @@ void compareOutput(std::vector<T>& tensor1, std::vector<T>& tensor2, size_t size
 TEST_SUITE("model_runner")
 {
 
-    TEST_CASE("op_entry_add")
-    {
-        // Inputs/Outputs
-        tosa_datatype_t dt                = tosa_datatype_fp32_t;
-        std::vector<int32_t> input_shape  = { 2, 4, 4, 1 };
-        std::vector<int32_t> output_shape = { 2, 4, 4, 1 };
-        std::vector<float> srcData1(32, 4.0f);
-        std::vector<float> srcData2(32, 3.0f);
-        std::vector<float> dstData(32, 0.0f);
-
-        tosa_tensor_t input1;
-        input1.shape     = input_shape.data();
-        input1.num_dims  = input_shape.size();
-        input1.data_type = dt;
-        input1.data      = reinterpret_cast<uint8_t*>(srcData1.data());
-        input1.size      = srcData1.size() * sizeof(float);
-
-        tosa_tensor_t input2;
-        input2.shape     = input_shape.data();
-        input2.num_dims  = input_shape.size();
-        input2.data_type = dt;
-        input2.data      = reinterpret_cast<uint8_t*>(srcData2.data());
-        input2.size      = srcData2.size() * sizeof(float);
-
-        tosa_tensor_t output;
-        output.shape     = output_shape.data();
-        output.num_dims  = output_shape.size();
-        output.data_type = dt;
-        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
-        output.size      = dstData.size() * sizeof(float);
-
-        // Execution
-        auto status = tosa_run_add(input1, input2, output, {});
-        CHECK((status == tosa_status_valid));
-
-        // Compare results
-        std::vector<float> expectedData(8, 7.0f);
-        compareOutput(dstData, expectedData, expectedData.size());
-    }
-
-    TEST_CASE("op_entry_avg_pool2d")
-    {
-        // Pool parameters
-        const int32_t kernel[2] = { 2, 2 };
-        const int32_t stride[2] = { 2, 2 };
-        const int32_t pad[4]    = { 0, 0, 0, 0 };
-
-        // Inputs/Outputs
-        tosa_datatype_t dt                = tosa_datatype_fp32_t;
-        std::vector<int32_t> input_shape  = { 2, 4, 4, 1 };
-        std::vector<int32_t> output_shape = { 2, 2, 2, 1 };
-        std::vector<float> srcData(32, 7.0f);
-        std::vector<float> dstData(8, 0.f);
-
-        tosa_tensor_t input;
-        input.shape     = input_shape.data();
-        input.num_dims  = input_shape.size();
-        input.data_type = dt;
-        input.data      = reinterpret_cast<uint8_t*>(srcData.data());
-        input.size      = srcData.size() * sizeof(float);
-
-        tosa_tensor_t output;
-        output.shape     = output_shape.data();
-        output.num_dims  = output_shape.size();
-        output.data_type = dt;
-        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
-        output.size      = dstData.size() * sizeof(float);
-
-        tosa_acc_size_t acc_size = tosa_acc_size_fp32_t;
-
-        // Execution
-        auto status = tosa_run_avg_pool2d(input, kernel, stride, pad, acc_size, 0, 0, output, {});
-        CHECK((status == tosa_status_valid));
-
-        // Compare results
-        std::vector<float> expectedData(8, 7.0f);
-        compareOutput(dstData, expectedData, expectedData.size());
-    }
-
-    TEST_CASE("op_entry_cast")
-    {
-        // Inputs/Outputs
-        std::vector<int32_t> shape   = { 1, 2, 2, 1 };
-        std::vector<int16_t> srcData = { 15, 13, 5, -51 };
-        std::vector<float> dstData(4, 0.f);
-
-        tosa_tensor_t input;
-        input.shape     = shape.data();
-        input.num_dims  = shape.size();
-        input.data_type = tosa_datatype_int16_t;
-        input.data      = reinterpret_cast<uint8_t*>(srcData.data());
-        input.size      = srcData.size() * sizeof(int16_t);
-
-        tosa_tensor_t output;
-        output.shape     = shape.data();
-        output.num_dims  = shape.size();
-        output.data_type = tosa_datatype_fp32_t;
-        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
-        output.size      = dstData.size() * sizeof(float);
-
-        // Execution
-        auto status = tosa_run_cast(input, output, {});
-        CHECK((status == tosa_status_valid));
-
-        // Compare results
-        std::vector<float> expectedData = { 15.f, 13.f, 5.f, -51.f };
-        compareOutput(dstData, expectedData, expectedData.size());
-    }
-
-    TEST_CASE("op_entry_concat")
-    {
-        // Concat parameters
-        const int32_t axis = 2;
-
-        // Inputs/Outputs
-        tosa_datatype_t dt                = tosa_datatype_fp32_t;
-        std::vector<int32_t> input1_shape = { 1, 2, 3, 4 };
-        std::vector<int32_t> input2_shape = { 1, 2, 5, 4 };
-        std::vector<int32_t> output_shape = { 1, 2, 8, 4 };
-        std::vector<float> src1Data(24, 1.0f);
-        std::vector<float> src2Data(40, 1.0f);
-        std::vector<float> dstData(64, 0.f);
-
-        tosa_tensor_t input1;
-        input1.shape     = input1_shape.data();
-        input1.num_dims  = input1_shape.size();
-        input1.data_type = dt;
-        input1.data      = reinterpret_cast<uint8_t*>(src1Data.data());
-        input1.size      = src1Data.size() * sizeof(float);
-
-        tosa_tensor_t input2;
-        input2.shape     = input2_shape.data();
-        input2.num_dims  = input2_shape.size();
-        input2.data_type = dt;
-        input2.data      = reinterpret_cast<uint8_t*>(src2Data.data());
-        input2.size      = src2Data.size() * sizeof(float);
-
-        tosa_tensor_list_t input_list;
-        tosa_tensor_t inputs[]{ input1, input2 };
-        input_list.size    = 2;
-        input_list.tensors = inputs;
-
-        tosa_tensor_t output;
-        output.shape     = output_shape.data();
-        output.num_dims  = output_shape.size();
-        output.data_type = dt;
-        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
-        output.size      = dstData.size() * sizeof(float);
-
-        auto status = tosa_run_concat(input_list, axis, output, {});
-        CHECK((status == tosa_status_valid));
-
-        std::vector<float> expectedData(64, 1.0f);
-        compareOutput(dstData, expectedData, expectedData.size());
-    }
-
-    TEST_CASE("op_entry_conv2d")
-    {
-        // Conv parameters
-        const int32_t stride[2]   = { 1, 1 };
-        const int32_t pad[4]      = { 0, 0, 0, 0 };
-        const int32_t dilation[2] = { 1, 1 };
-
-        // Inputs/Outputs
-        tosa_datatype_t dt                = tosa_datatype_fp32_t;
-        std::vector<int32_t> input_shape  = { 1, 32, 32, 8 };
-        std::vector<int32_t> output_shape = { 1, 32, 32, 16 };
-        std::vector<int32_t> weight_shape = { 16, 1, 1, 8 };
-        std::vector<int32_t> bias_shape   = { 16 };
-        std::vector<float> srcData(32 * 32 * 8, 1.0f);
-        std::vector<float> dstData(32 * 32 * 16, 0.f);
-        std::vector<float> biasData(16, 0.f);
-        std::vector<float> weightData(16 * 8, 1.0f);
-
-        tosa_tensor_t input;
-        input.shape     = input_shape.data();
-        input.num_dims  = input_shape.size();
-        input.data_type = dt;
-        input.data      = reinterpret_cast<uint8_t*>(srcData.data());
-        input.size      = srcData.size() * sizeof(float);
-
-        tosa_tensor_t weight;
-        weight.shape     = weight_shape.data();
-        weight.num_dims  = weight_shape.size();
-        weight.data_type = dt;
-        weight.data      = reinterpret_cast<uint8_t*>(weightData.data());
-        weight.size      = weightData.size() * sizeof(float);
-
-        tosa_tensor_t bias;
-        bias.shape     = bias_shape.data();
-        bias.num_dims  = bias_shape.size();
-        bias.data_type = dt;
-        bias.data      = reinterpret_cast<uint8_t*>(biasData.data());
-        bias.size      = biasData.size() * sizeof(float);
-
-        tosa_tensor_t output;
-        output.shape     = output_shape.data();
-        output.num_dims  = output_shape.size();
-        output.data_type = dt;
-        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
-        output.size      = dstData.size() * sizeof(float);
-
-        const int32_t input_zp  = 0;
-        const int32_t weight_zp = 0;
-        const bool local_bound  = false;
-
-        // Execution
-        auto status =
-            tosa_run_conv2d(input, weight, bias, pad, stride, dilation, input_zp, weight_zp, local_bound, output, {});
-        CHECK((status == tosa_status_valid));
-
-        // Compare results
-        std::vector<float> expectedData(32 * 32 * 16, 8.0f);
-        compareOutput(dstData, expectedData, expectedData.size());
-    }
-
-    TEST_CASE("op_entry_fft2d")
-    {
-        // Fft2d parameters
-        const bool inverse     = false;
-        const bool local_bound = false;
-
-        // Inputs/Outputs
-        tosa_datatype_t dt                     = tosa_datatype_fp32_t;
-        std::vector<int32_t> input_shape_real  = { 1, 32, 32 };
-        std::vector<int32_t> output_shape_real = { 1, 32, 32 };
-        std::vector<int32_t> input_shape_imag  = { 1, 32, 32 };
-        std::vector<int32_t> output_shape_imag = { 1, 32, 32 };
-        std::vector<float> srcData(32 * 32 * 1, 0.f);
-        std::vector<float> dstDataReal(32 * 32 * 1, 0.f);
-        std::vector<float> dstDataImag(32 * 32 * 1, 0.f);
-
-        tosa_tensor_t input_real;
-        input_real.shape     = input_shape_real.data();
-        input_real.num_dims  = input_shape_real.size();
-        input_real.data_type = dt;
-        input_real.data      = reinterpret_cast<uint8_t*>(srcData.data());
-        input_real.size      = srcData.size() * sizeof(float);
-
-        tosa_tensor_t input_imag;
-        input_imag.shape     = input_shape_imag.data();
-        input_imag.num_dims  = input_shape_imag.size();
-        input_imag.data_type = dt;
-        input_imag.data      = reinterpret_cast<uint8_t*>(srcData.data());
-        input_imag.size      = srcData.size() * sizeof(float);
-
-        tosa_tensor_t output_real;
-        output_real.shape     = output_shape_real.data();
-        output_real.num_dims  = output_shape_real.size();
-        output_real.data_type = dt;
-        output_real.data      = reinterpret_cast<uint8_t*>(dstDataReal.data());
-        output_real.size      = dstDataReal.size() * sizeof(float);
-
-        tosa_tensor_t output_imag;
-        output_imag.shape     = output_shape_imag.data();
-        output_imag.num_dims  = output_shape_imag.size();
-        output_imag.data_type = dt;
-        output_imag.data      = reinterpret_cast<uint8_t*>(dstDataImag.data());
-        output_imag.size      = dstDataImag.size() * sizeof(float);
-
-        // Execution
-        auto status = tosa_run_fft2d(input_real, input_imag, inverse, output_real, local_bound, output_imag, {});
-        CHECK((status == tosa_status_valid));
-
-        // Compare results
-        std::vector<float> expectedDataReal = {};
-        std::vector<float> expectedDataImag = {};
-        for (unsigned i = 0; i < dstDataReal.size(); ++i)
-        {
-            std::vector<float> sum_real = {};
-            std::vector<float> sum_imag = {};
-            for (unsigned j = 0; j < dstDataImag.size(); ++j)
-            {
-                float a = ((inverse) ? -1 : 1) * 402.123859659; /* 2 * pi * ((iY * oY) / H + (iX * oX) / W) */
-                sum_real.emplace_back(srcData[j] * std::cos(a) + srcData[j] * std::sin(a));
-                sum_imag.emplace_back((-1) * srcData[j] * std::sin(a) + srcData[j] * std::sin(a));
-            }
-            expectedDataReal.emplace_back(sum_real[i]);
-            expectedDataImag.emplace_back(sum_imag[i]);
-        }
-        compareOutput(dstDataReal, expectedDataReal, expectedDataReal.size());
-        compareOutput(dstDataImag, expectedDataImag, expectedDataImag.size());
-    }
-
-    TEST_CASE("op_entry_rfft2d")
-    {
-        // Rfft2d parameters
-        const bool local_bound = false;
-
-        // Inputs/Outputs
-        tosa_datatype_t dt                     = tosa_datatype_fp32_t;
-        std::vector<int32_t> input_shape       = { 1, 32, 32 };
-        std::vector<int32_t> output_shape_real = { 1, 32, 17 };
-        std::vector<int32_t> output_shape_imag = { 1, 32, 17 };
-        std::vector<float> srcData(32 * 32 * 1, 0.f);
-        std::vector<float> dstDataReal(32 * 17 * 1, 0.f);
-        std::vector<float> dstDataImag(32 * 17 * 1, 0.f);
-
-        tosa_tensor_t input;
-        input.shape     = input_shape.data();
-        input.num_dims  = input_shape.size();
-        input.data_type = dt;
-        input.data      = reinterpret_cast<uint8_t*>(srcData.data());
-        input.size      = srcData.size() * sizeof(float);
-
-        tosa_tensor_t output_real;
-        output_real.shape     = output_shape_real.data();
-        output_real.num_dims  = output_shape_real.size();
-        output_real.data_type = dt;
-        output_real.data      = reinterpret_cast<uint8_t*>(dstDataReal.data());
-        output_real.size      = dstDataReal.size() * sizeof(float);
-
-        tosa_tensor_t output_imag;
-        output_imag.shape     = output_shape_imag.data();
-        output_imag.num_dims  = output_shape_imag.size();
-        output_imag.data_type = dt;
-        output_imag.data      = reinterpret_cast<uint8_t*>(dstDataImag.data());
-        output_imag.size      = dstDataImag.size() * sizeof(float);
-
-        // Execution
-        auto status = tosa_run_rfft2d(input, output_real, local_bound, output_imag, {});
-        CHECK((status == tosa_status_valid));
-
-        // Compare results
-        std::vector<float> expectedDataReal = {};
-        std::vector<float> expectedDataImag = {};
-        for (unsigned i = 0; i < dstDataReal.size(); ++i)
-        {
-            std::vector<float> sum_real = {};
-            std::vector<float> sum_imag = {};
-            for (unsigned j = 0; j < dstDataImag.size(); ++j)
-            {
-                float a = 307.876080052; /* 2 * pi * ((iY * oY) / H + (iX * oX) / W) */
-                sum_real.emplace_back(srcData[j] * std::cos(a));
-                sum_imag.emplace_back((-1) * srcData[j] * std::sin(a));
-            }
-            expectedDataReal.emplace_back(sum_real[i]);
-            expectedDataImag.emplace_back(sum_imag[i]);
-        }
-        compareOutput(dstDataReal, expectedDataReal, expectedDataReal.size());
-        compareOutput(dstDataImag, expectedDataImag, expectedDataImag.size());
-    }
-
-    TEST_CASE("op_entry_transpose_conv2d")
-    {
-        // Transpose Conv 2D parameters
-        const int32_t stride[2]    = { 1, 1 };
-        const int32_t out_pad[4]   = { 0, 0, 0, 0 };
-        const int32_t out_shape[4] = { 1, 32, 32, 16 };
-
-        // Inputs/Outputs
-        tosa_datatype_t dt                = tosa_datatype_fp32_t;
-        std::vector<int32_t> input_shape  = { 1, 32, 32, 8 };
-        std::vector<int32_t> output_shape = { 1, 32, 32, 16 };
-        std::vector<int32_t> weight_shape = { 16, 1, 1, 8 };
-        std::vector<int32_t> bias_shape   = { 16 };
-
-        std::vector<float> srcData(32 * 32 * 8, 1.0f);
-        std::vector<float> dstData(32 * 32 * 16, 0.f);
-        std::vector<float> biasData(16, 0.f);
-        std::vector<float> weightData(16 * 8, 1.0f);
-
-        tosa_tensor_t input;
-        input.shape     = input_shape.data();
-        input.num_dims  = input_shape.size();
-        input.data_type = dt;
-        input.data      = reinterpret_cast<uint8_t*>(srcData.data());
-        input.size      = srcData.size() * sizeof(float);
-
-        tosa_tensor_t weight;
-        weight.shape     = weight_shape.data();
-        weight.num_dims  = weight_shape.size();
-        weight.data_type = dt;
-        weight.data      = reinterpret_cast<uint8_t*>(weightData.data());
-        weight.size      = weightData.size() * sizeof(float);
-
-        tosa_tensor_t bias;
-        bias.shape     = bias_shape.data();
-        bias.num_dims  = bias_shape.size();
-        bias.data_type = dt;
-        bias.data      = reinterpret_cast<uint8_t*>(biasData.data());
-        bias.size      = biasData.size() * sizeof(float);
-
-        tosa_tensor_t output;
-        output.shape     = output_shape.data();
-        output.num_dims  = output_shape.size();
-        output.data_type = dt;
-        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
-        output.size      = dstData.size() * sizeof(float);
-
-        const int32_t input_zp  = 0;
-        const int32_t weight_zp = 0;
-        const bool local_bound  = false;
-
-        // Execution
-        auto status = tosa_run_transpose_conv2d(input, weight, bias, out_pad, stride, out_shape, input_zp, weight_zp,
-                                                local_bound, output, {});
-        CHECK((status == tosa_status_valid));
-
-        // Compare results
-        std::vector<float> expectedData(32 * 32 * 16, 8.0f);
-        compareOutput(dstData, expectedData, expectedData.size());
-    }
-
-    TEST_CASE("op_entry_conv2d_abs_mode")
-    {
-        // Conv parameters
-        const int32_t stride[2]   = { 1, 1 };
-        const int32_t pad[4]      = { 0, 0, 0, 0 };
-        const int32_t dilation[2] = { 1, 1 };
-
-        // Inputs/Outputs
-        tosa_datatype_t dt                = tosa_datatype_fp32_t;
-        std::vector<int32_t> input_shape  = { 1, 32, 32, 8 };
-        std::vector<int32_t> output_shape = { 1, 32, 32, 16 };
-        std::vector<int32_t> weight_shape = { 16, 1, 1, 8 };
-        std::vector<int32_t> bias_shape   = { 16 };
-        std::vector<float> srcData(32 * 32 * 8, -1.0f);
-        std::vector<float> dstData(32 * 32 * 16, 0.f);
-        std::vector<float> biasData(16, 0.f);
-        std::vector<float> weightData(16 * 8, 1.0f);
-
-        tosa_tensor_t input;
-        input.shape     = input_shape.data();
-        input.num_dims  = input_shape.size();
-        input.data_type = dt;
-        input.data      = reinterpret_cast<uint8_t*>(srcData.data());
-        input.size      = srcData.size() * sizeof(float);
-
-        tosa_tensor_t weight;
-        weight.shape     = weight_shape.data();
-        weight.num_dims  = weight_shape.size();
-        weight.data_type = dt;
-        weight.data      = reinterpret_cast<uint8_t*>(weightData.data());
-        weight.size      = weightData.size() * sizeof(float);
-
-        tosa_tensor_t bias;
-        bias.shape     = bias_shape.data();
-        bias.num_dims  = bias_shape.size();
-        bias.data_type = dt;
-        bias.data      = reinterpret_cast<uint8_t*>(biasData.data());
-        bias.size      = biasData.size() * sizeof(float);
-
-        tosa_tensor_t output;
-        output.shape     = output_shape.data();
-        output.num_dims  = output_shape.size();
-        output.data_type = dt;
-        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
-        output.size      = dstData.size() * sizeof(float);
-
-        const int32_t input_zp  = 0;
-        const int32_t weight_zp = 0;
-        const bool local_bound  = false;
-
-        // Execution
-        func_ctx_t func_ctx;
-        func_ctx.func_config.abs_mode = true;
-        auto status = tosa_run_conv2d(input, weight, bias, pad, stride, dilation, input_zp, weight_zp, local_bound,
-                                      output, func_ctx);
-        CHECK((status == tosa_status_valid));
-
-        // Compare results
-        std::vector<float> expectedData(32 * 32 * 16, 8.0f);
-        compareOutput(dstData, expectedData, expectedData.size());
-    }
-
-    TEST_CASE("op_entry_max_pool2d")
-    {
-        // Pool parameters
-        const int32_t kernel[2] = { 2, 2 };
-        const int32_t stride[2] = { 2, 2 };
-        const int32_t pad[4]    = { 0, 0, 0, 0 };
-
-        // Inputs/Outputs
-        tosa_datatype_t dt                = tosa_datatype_fp32_t;
-        std::vector<int32_t> input_shape  = { 2, 4, 4, 1 };
-        std::vector<int32_t> output_shape = { 2, 2, 2, 1 };
-        std::vector<float> srcData(32);
-        std::vector<float> dstData(8, 0.f);
-        std::iota(std::begin(srcData), std::end(srcData), 1);
-
-        tosa_tensor_t input;
-        input.shape     = input_shape.data();
-        input.num_dims  = input_shape.size();
-        input.data_type = dt;
-        input.data      = reinterpret_cast<uint8_t*>(srcData.data());
-        input.size      = srcData.size() * sizeof(float);
-
-        tosa_tensor_t output;
-        output.shape     = output_shape.data();
-        output.num_dims  = output_shape.size();
-        output.data_type = dt;
-        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
-        output.size      = dstData.size() * sizeof(float);
-
-        // Execution
-        auto status = tosa_run_max_pool2d(input, kernel, stride, pad, 0, 0, output, {});
-        CHECK((status == tosa_status_valid));
-
-        // Compare results
-        std::vector<float> expectedData = { 6, 8, 14, 16, 22, 24, 30, 32 };
-        compareOutput(dstData, expectedData, expectedData.size());
-    }
-
-    TEST_CASE("op_entry_pad")
-    {
-        // Inputs/Outputs
-        tosa_datatype_t dt                 = tosa_datatype_fp32_t;
-        std::vector<int32_t> input_shape   = { 2, 2 };
-        std::vector<int32_t> padding_shape = { 1, 4 };
-        std::vector<int32_t> output_shape  = { 4, 4 };
-        std::vector<float> srcData1(4, 4.0f);
-        std::vector<int32_t> padData(4, 1);
-        std::vector<float> dstData(16, 0.0f);
-
-        tosa_tensor_t input1;
-        input1.shape     = input_shape.data();
-        input1.num_dims  = input_shape.size();
-        input1.data_type = dt;
-        input1.data      = reinterpret_cast<uint8_t*>(srcData1.data());
-        input1.size      = srcData1.size() * sizeof(float);
-
-        tosa_tensor_t padding;
-        padding.shape     = padding_shape.data();
-        padding.num_dims  = padding_shape.size();
-        padding.data_type = tosa_datatype_int32_t;
-        padding.data      = reinterpret_cast<uint8_t*>(padData.data());
-        padding.size      = padData.size() * sizeof(int32_t);
-
-        tosa_tensor_t output;
-        output.shape     = output_shape.data();
-        output.num_dims  = output_shape.size();
-        output.data_type = dt;
-        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
-        output.size      = dstData.size() * sizeof(float);
-
-        // Execution
-        int32_t pad_const_int = 0;
-        float pad_const_fp    = 5.0f;
-        auto status           = tosa_run_pad(input1, padding, pad_const_int, pad_const_fp, output, func_ctx_t{});
-        CHECK((status == tosa_status_valid));
-
-        // Compare results
-        // Expect a 4x4 array with a border of 5's and inner 2x2 of 4's
-        std::vector<float> expectedData(16, 5.0f);
-        expectedData[5]  = 4.0f;
-        expectedData[6]  = 4.0f;
-        expectedData[9]  = 4.0f;
-        expectedData[10] = 4.0f;
-        compareOutput(dstData, expectedData, expectedData.size());
-    }
-
-    TEST_CASE("op_entry_reshape")
-    {
-        // Inputs/Outputs
-        tosa_datatype_t dt                = tosa_datatype_fp32_t;
-        std::vector<int32_t> input_shape  = { 2, 2 };
-        std::vector<int32_t> new_shape    = { 1, 2 };
-        std::vector<int32_t> output_shape = { 4, 1 };
-        std::vector<float> srcData1(4, 4.0f);
-        std::vector<int32_t> shapeData = { 4, 1 };
-        std::vector<float> dstData(4, 0.0f);
-
-        tosa_tensor_t input1;
-        input1.shape     = input_shape.data();
-        input1.num_dims  = input_shape.size();
-        input1.data_type = dt;
-        input1.data      = reinterpret_cast<uint8_t*>(srcData1.data());
-        input1.size      = srcData1.size() * sizeof(float);
-
-        tosa_tensor_t shape;
-        shape.shape     = new_shape.data();
-        shape.num_dims  = new_shape.size();
-        shape.data_type = tosa_datatype_int32_t;
-        shape.data      = reinterpret_cast<uint8_t*>(shapeData.data());
-        shape.size      = shapeData.size() * sizeof(int32_t);
-
-        tosa_tensor_t output;
-        output.shape     = output_shape.data();
-        output.num_dims  = output_shape.size();
-        output.data_type = dt;
-        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
-        output.size      = dstData.size() * sizeof(float);
-
-        // Execution
-        auto status = tosa_run_reshape(input1, shape, output, func_ctx_t{});
-        CHECK((status == tosa_status_valid));
-
-        // Compare results
-        std::vector<float> expectedData(4, 4.0f);
-        compareOutput(dstData, expectedData, expectedData.size());
-    }
-
-    TEST_CASE("op_entry_tile")
-    {
-        // Inputs/Outputs
-        tosa_datatype_t dt                   = tosa_datatype_fp32_t;
-        std::vector<int32_t> input_shape     = { 2, 3 };
-        std::vector<int32_t> multiples_shape = { 1, 2 };
-        std::vector<int32_t> output_shape    = { 2, 6 };
-        std::vector<float> srcData1          = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
-        std::vector<int32_t> multiples_data  = { 1, 2 };
-        std::vector<float> dstData(12, 0.0f);
-
-        tosa_tensor_t input1;
-        input1.shape     = input_shape.data();
-        input1.num_dims  = input_shape.size();
-        input1.data_type = dt;
-        input1.data      = reinterpret_cast<uint8_t*>(srcData1.data());
-        input1.size      = srcData1.size() * sizeof(float);
-
-        tosa_tensor_t multiples;
-        multiples.shape     = multiples_shape.data();
-        multiples.num_dims  = multiples_shape.size();
-        multiples.data_type = tosa_datatype_int32_t;
-        multiples.data      = reinterpret_cast<uint8_t*>(multiples_data.data());
-        multiples.size      = multiples_data.size() * sizeof(int32_t);
-
-        tosa_tensor_t output;
-        output.shape     = output_shape.data();
-        output.num_dims  = output_shape.size();
-        output.data_type = dt;
-        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
-        output.size      = dstData.size() * sizeof(float);
-
-        // Execution
-        auto status = tosa_run_tile(input1, multiples, output, {});
-        CHECK((status == tosa_status_valid));
-
-        // Compare results
-        std::vector<float> expectedData = { 1.0, 2.0, 3.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 4.0, 5.0, 6.0 };
-        compareOutput(dstData, expectedData, expectedData.size());
-    }
-
     TEST_CASE("simple_add_f32_test")
     {
         std::string test_root(std::string(PROJECT_ROOT) + "../examples/test_add_1x4x4x4_f32/");
diff --git a/scripts/operator_api/README.md b/scripts/operator_api/README.md
deleted file mode 100644
index 381d90c..0000000
--- a/scripts/operator_api/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# Generate eager operator execution entrypoints
-
-## Introduction
-
-The generate_api.py script will generate an extended reference model API with eager operator execution entrypoints.
-The following files will be generated: include/operators.h and src/operators.cc
-
-## Requirements
-
-* Python 3.6 or later
-* Jinja2 (install with ```pip install Jinja2```)
-
-## Running from the command line
-
-The script can be run from the scripts/operator-api directory as follows:
-
-```bash
-python generate_api.py
-```
diff --git a/scripts/operator_api/generate_api.py b/scripts/operator_api/generate_api.py
deleted file mode 100644
index e511f19..0000000
--- a/scripts/operator_api/generate_api.py
+++ /dev/null
@@ -1,413 +0,0 @@
-"""Generate extended reference model API with eager operator execution entrypoints"""
-# Copyright (c) 2021-2023, ARM Limited.
-# SPDX-License-Identifier: Apache-2.0
-import copy
-import os
-import subprocess
-from pathlib import Path
-from xml.dom import minidom
-
-from jinja2 import Environment
-from jinja2 import FileSystemLoader
-
-
-def getBasePath():
-    return Path(__file__).resolve().parent.parent.parent
-
-
-def getTosaArgTypes(tosaXml):
-    """
-    Returns a list of the TOSA argument types from tosa.xml.
-    """
-    argTypes = {
-        "tensor_t",
-        "in_t",
-        "out_t",
-        "mul_t",
-        "weight_t",
-        "in_out_t",
-        "tensor_list_t",
-    }
-    argTypesXml = tosaXml.getElementsByTagName("type")
-    for argTypeXml in argTypesXml:
-        argTypes.add(argTypeXml.getAttribute("name"))
-    argTypes.remove("TABLE_SIZE")
-    return argTypes
-
-
-def getTosaDataTypes(tosaXml):
-    """
-    Returns a list of the TOSA data types from tosa.xml.
-    """
-    argTypes = getTosaArgTypes(tosaXml)
-    dataTypes = set()
-    dataTypesXml = tosaXml.getElementsByTagName("typesupport")
-    for dataTypeXml in dataTypesXml:
-        for argType in argTypes:
-            dataType = dataTypeXml.getAttribute(argType)
-            if dataType != "":
-                dataTypes.add(f"tosa_datatype_{dataType}")
-    return sorted(dataTypes)
-
-
-def getSerializeOpType(tosaOpName):
-    """
-    Returns the Serialization library operator that matches the TOSA operator specified.
-    """
-    map = {
-        "avg_pool2d": "Pool",
-        "conv2d": "Conv",
-        "conv3d": "Conv",
-        "depthwise_conv2d": "Conv",
-        "fully_connected": "FullyConnected",
-        "fft2d": "FFT",
-        "rfft2d": "RFFT",
-        "matmul": "MatMul",
-        "max_pool2d": "Pool",
-        "transpose_conv2d": "TransposeConv",
-        "clamp": "Clamp",
-        "arithmetic_right_shift": "ArithmeticRightShift",
-        "mul": "Mul",
-        "table": "Table",
-        "negate": "Negate",
-        "pad": "Pad",
-        "reshape": "Reshape",
-        "slice": "Slice",
-        "tile": "Tile",
-        "transpose": "Transpose",
-        "resize": "Resize",
-        "rescale": "Rescale",
-        "cond_if": "CondIf",
-        "while_loop": "WhileLoop",
-    }
-    return map.get(tosaOpName, "None")
-
-
-def getSerialLibAttsForOp(tosaOpName, allSerialLibAtts, tosaArgs):
-    """
-    Returns the attributes required by the Serialization library for the TOSA operator specified.
-    Generates code to initialize Serialization library attributes. If a matching TOSA argument exists,
-    that value is used for initialization, otherwise a default value e.g. 0 is used.
-    """
-    serLibOpType = getSerializeOpType(tosaOpName)
-    if serLibOpType not in allSerialLibAtts.keys():
-        return {}
-    else:
-        serLibOpAtts = copy.deepcopy(allSerialLibAtts[serLibOpType])
-        tosaArgsDict = {arg["name"]: arg for arg in tosaArgs}
-        serTosaTypeMap = {"ResizeMode": "tosa_mode"}
-        serAttsToFix = {
-            "reshape": {"new_shape": "shape"},
-            "transpose_conv2d": {"output_shape": "out_shape"},
-        }
-        if tosaOpName in serAttsToFix:
-            # Fix attributes names to match with tosa.xml
-            for attDefName, tosaSpecName in serAttsToFix[tosaOpName].items():
-                for opAtts in serLibOpAtts:
-                    if opAtts["name"] == attDefName:
-                        opAtts["name"] = tosaSpecName
-        for att in serLibOpAtts:
-            attName = att["name"]
-            attType = att["dType"]
-            init = ""
-            # Translate TOSA data types to Serialization library data types for initialization
-            if attType in serTosaTypeMap.keys():
-                init = f"const {attType} {attName} = translate_client_{serTosaTypeMap[att['dType']]}(client_{attName});"
-            # Initialize Serialization library attributes to their matching function parameter
-            elif tosaOpName == "avg_pool2d" and attName == "accum_dtype":
-                init = f"const tosa::DType {attName} = translate_client_acc_size(client_acc_size);"
-                att["dType"] = "tosa::DType"
-            elif attName in tosaArgsDict:
-                if att["SV"] == "V":
-                    if tosaArgsDict[attName]["type"] == "tosa_tensor_t":
-                        init = f"std::vector<{attType}> {attName};"
-                        init = (
-                            init
-                            + f"size_t {attName}_size = client_{attName}.size / sizeof({attType});"
-                        )
-                        init = (
-                            init
-                            + f"{attType}* {attName}_data = reinterpret_cast<{attType}*>(client_{attName}.data);"
-                        )
-                        init = (
-                            init
-                            + f"{attName}.assign({attName}_data, {attName}_data + {attName}_size);"
-                        )
-                    else:
-                        init = f"const std::vector<{attType}> {attName}"
-                        shape = tosaArgsDict[attName]["shape"]
-                        if shape == "[]":
-                            init = (
-                                init
-                                + f"(&client_{attName}[0], &client_{attName}[0] + client_{attName}_len);"
-                            )
-                        else:
-                            init = (
-                                init
-                                + f"(&client_{attName}[0], &client_{attName}{shape});"
-                            )
-                else:
-                    init = ""
-            else:
-                # Initialize Serialization library attributes with no matching fuction parameter
-                if att["SV"] == "V":
-                    init = f"std::vector<int32_t> {attName};"
-                else:
-                    if att["dType"] == "DType":
-                        att["dType"] = "tosa::DType"
-                        init = f"const tosa::DType {attName} = tosa::DType::DType_FP32;"
-                    else:
-                        init = f"const {attType} {attName} = 0;"
-            att["init"] = init
-        return serLibOpAtts
-
-
-def updateTosaArgs(tosaArgs, serialLibAtts, tosaXml):
-    """
-    Replace TOSA argument data types with their matching Serialization attribute data types.
-    Delete TOSA arguments where the type couldn't be determined.
-    Add Serialization attributes that have no matching TOSA argument.
-    """
-    tosaArgTypes = getTosaArgTypes(tosaXml)
-    serAttsDict = {att["name"]: att for att in serialLibAtts}
-    tosaArgsNames = [arg["name"] for arg in tosaArgs]
-    delTosaArgs = []
-    # Replace TOSA argument data types with their matching Serialization attribute data types.
-    for tosaArg in tosaArgs:
-        if tosaArg["type"] in tosaArgTypes:
-            if tosaArg["name"] in serAttsDict:
-                tosaArg["type"] = serAttsDict[tosaArg["name"]]["dType"]
-            else:
-                # Delete TOSA argument whose data type can't be determined
-                delTosaArgs.append(tosaArgsNames.index(tosaArg["name"]))
-                # Delete corresponding length argument if one exists
-                lenArgName = f"{tosaArg['name']}_len"
-                if lenArgName in tosaArgsNames:
-                    delTosaArgs.append(tosaArgsNames.index(lenArgName))
-    # Delete TOSA arguments where the type couldn't be determined
-    for index in sorted(delTosaArgs, key=int, reverse=True):
-        del tosaArgs[index]
-    # Add Serialization attributes that have no matching TOSA argument
-    tosaArgNames = [arg["name"] for arg in tosaArgs]
-    for serAtt in serialLibAtts:
-        attName = serAtt["name"]
-        attType = serAtt["dType"]
-        if (attName not in tosaArgNames) and (not attType == "tosa::DType"):
-            serAttName = serAtt["name"]
-            if serAtt["SV"] == "V":
-                # For vector data types, insert a matching length argument
-                tosaArgs.insert(
-                    len(tosaArgs) - 1,
-                    {
-                        "name": f"{serAttName}_len",
-                        "type": "int32_t",
-                        "shape": "",
-                        "category": "",
-                    },
-                )
-                init = f"const std::vector<{attType}> {attName}(&client_{serAttName}[0], &client_{serAttName}[0] + client_{serAttName}_len);"
-                shape = "[]"
-            else:
-                init = ""
-                shape = ""
-            serAtt["init"] = init
-            # Insert new argument
-            tosaArgs.insert(
-                len(tosaArgs) - 1,
-                {
-                    "name": serAttName,
-                    "type": serAtt["dType"],
-                    "shape": shape,
-                    "category": "",
-                },
-            )
-
-
-def getOperators(tosaXml):
-    """
-    Return a list of TOSA operators as defined by tosa.xml.
-    """
-    operators = []
-    ignoreOps = [
-        "while_loop",
-        "cond_if",
-        "const",
-        "custom",
-        "variable",
-        "variable_read",
-        "variable_write",
-    ]
-    opsXml = tosaXml.getElementsByTagName("operator")
-    allSerialLibAtts = getSerialLibAtts()
-    for opXml in opsXml:
-        opName = opXml.getElementsByTagName("name")[0].firstChild.data.lower()
-        if opName not in ignoreOps:
-            operator = {"name": opName}
-            operator["serializeAttType"] = getSerializeOpType(opName)
-            tosaArgs = getTosaArgs(opXml)
-            serialLibAtts = getSerialLibAttsForOp(opName, allSerialLibAtts, tosaArgs)
-            # Handle "axis" arguments
-            axisList = [arg["name"] for arg in tosaArgs if arg["name"] == "axis"]
-            if operator["serializeAttType"] == "None" and len(axisList) > 0:
-                operator["serializeAttType"] = "Axis"
-                serialLibAtts = [
-                    {
-                        "name": "axis",
-                        "dType": "int32_t",
-                        "SV": "S",
-                        "init": "",
-                    }
-                ]
-            updateTosaArgs(tosaArgs, serialLibAtts, tosaXml)
-            operator["arguments"] = tosaArgs
-            operator["serialLibAtts"] = serialLibAtts
-            serializationAttNames = [att["name"] for att in serialLibAtts]
-            operator["inputs"] = [
-                {"name": arg["name"], "type": arg["type"]}
-                for arg in tosaArgs
-                if arg["category"] == "input"
-                and arg["name"] not in serializationAttNames
-            ]
-            operator["outputs"] = [
-                arg["name"] for arg in tosaArgs if arg["category"] == "output"
-            ]
-            operators.append(operator)
-    return operators
-
-
-def getTosaArgs(opXml):
-    """
-    Return the arguments required for the TOSA operator specified.
-    """
-    arguments = []
-    argsXml = opXml.getElementsByTagName("argument")
-    tosaTensorTypes = getTosaArgTypes(tosaXml)
-    tosaTypeMap = {"bool_t": "bool", "uint6_t": "uint8_t", "mode_t": "tosa_mode_t"}
-    tensorElemTypeMap = {
-        "resize_mode_t": "tosa_mode_t",
-        "acc_size_t": "tosa_acc_size_t",
-    }
-    for xmlArg in argsXml:
-        argName = xmlArg.getAttribute("name").lower()
-        tensorElemType = xmlArg.getAttribute("tensor-element-type")
-        if tensorElemType in tensorElemTypeMap:
-            argType = tensorElemTypeMap[tensorElemType]
-        else:
-            argType = xmlArg.getAttribute("type")
-        argShape = xmlArg.getAttribute("shape")
-        argCategory = xmlArg.getAttribute("category")
-        # FullyConnected workaround
-        if (argName == "weight" or argName == "bias") and (argCategory == "attribute"):
-            argCategory = "input"
-        # Update argument type
-        if argType[-1:] == "*":
-            argType = argType[:-1]
-        if argCategory in ["input", "output"] and argType in tosaTensorTypes:
-            argType = f"tosa_{argType}"
-            argShape = ""
-        if argType in tosaTypeMap:
-            argType = tosaTypeMap[argType]
-        # Add a length argument for arrays with unknown compile-time size
-        if argShape != "" and argShape[0] == "[" and not argShape[1:-1].isnumeric():
-            argShape = "[]"
-            arguments.append(
-                {
-                    "name": f"{argName}_len",
-                    "type": "int32_t",
-                    "shape": "",
-                    "category": "",
-                }
-            )
-        elif argShape == "" or not argShape[0] == "[":
-            argShape = ""
-        # Append argument
-        arguments.append(
-            {
-                "name": argName,
-                "type": argType,
-                "shape": argShape,
-                "category": argCategory,
-            }
-        )
-    return arguments
-
-
-def clangFormat(filename):
-    cmd = ["clang-format", "-i", filename]
-    with open(os.devnull, "w") as devnull:
-        subprocess.check_call(cmd, stdout=devnull)
-
-
-def getSerialLibAtts():
-    """
-    Parse attribute.def file and return a dictionary where the keys are Serialization library operator names.
-    The values are the arguments required by each Serialization library operator.
-    """
-    serialLibAtts = {}
-    base_path = getBasePath()
-    attr_def = (
-        base_path / "thirdparty" / "serialization_lib" / "include" / "attribute.def"
-    )
-    with open(attr_def) as file:
-        preamble = True
-        inAtt = False
-        opName = ""
-        args = []
-        for line in file:
-            if preamble and not line[: len("DEF_ATTRIBUTE(")] == "DEF_ATTRIBUTE(":
-                continue
-            else:
-                preamble = False
-            line = line.lstrip().rstrip()
-            if not inAtt and "DEF_ATTRIBUTE(" in line:
-                opName = line[len("DEF_ATTRIBUTE(") : line.find(",")]
-                inAtt = True
-            elif inAtt:
-                vals = line.split(",")
-                argName = vals[2].lstrip().strip()
-                if ")" in argName:
-                    argName = argName[:-1]
-                arg = {
-                    "name": argName,
-                    "dType": vals[0].lstrip().strip(),
-                    "SV": vals[1].lstrip().strip(),
-                }
-                args.append(arg)
-                if ")" in line:
-                    serialLibAtts[opName] = args
-                    opName = ""
-                    args = []
-                    inAtt = False
-    return serialLibAtts
-
-
-def renderTemplate(dataTypes, operators, template, outfile):
-    content = template.render(dataTypes=dataTypes, operators=operators)
-    with open(outfile, mode="w", encoding="utf-8") as output:
-        output.write(content)
-        print(f"Created {outfile}")
-
-    clangFormat(outfile)
-
-
-def generate(environment, dataTypes, operators, base_path):
-    # Generate include/operators.h
-    template = environment.get_template("operators_h.j2")
-    outfile = base_path / "reference_model/include/operators.h"
-    renderTemplate(dataTypes, operators, template, outfile)
-
-    # Generate src/operators.cc
-    template = environment.get_template("operators_cc.j2")
-    outfile = base_path / "reference_model/src/operators.cc"
-    renderTemplate(dataTypes, operators, template, outfile)
-
-
-if __name__ == "__main__":
-    base_path = getBasePath()
-    environment = Environment(
-        loader=FileSystemLoader(Path(__file__).resolve().parent / "templates")
-    )
-    tosaXml = minidom.parse(str(base_path / "thirdparty/specification/tosa.xml"))
-    dataTypes = getTosaDataTypes(tosaXml)
-    operators = getOperators(tosaXml)
-    generate(environment, dataTypes, operators, base_path)
diff --git a/scripts/operator_api/templates/operators_cc.j2 b/scripts/operator_api/templates/operators_cc.j2
deleted file mode 100644
index 0fc52ab..0000000
--- a/scripts/operator_api/templates/operators_cc.j2
+++ /dev/null
@@ -1,248 +0,0 @@
-
-// Copyright (c) 2022-2023, ARM Limited.
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//         http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-
-// THIS FILE IS GENERATED. DO NOT EDIT!
-// See scripts/operator_api/generate_api.py
-
-#include "operators.h"
-#include "model_runner_impl.h"
-#include "ops/op_factory.h"
-
-
-#define TOSA_PROPAGATE_ERROR(status)                                                                                   \
-    do                                                                                                                 \
-    {                                                                                                                  \
-        if (status != 0)                                                                                               \
-        {                                                                                                              \
-            return status;                                                                                             \
-        }                                                                                                              \
-    } while (false)
-
-
-#define TOSA_RETURN_ON_ERROR(status)                                                                                   \
-    do                                                                                                                 \
-    {                                                                                                                  \
-        if (status != 0)                                                                                               \
-        {                                                                                                              \
-            return tosa_status_error;                                                                                  \
-        }                                                                                                              \
-    } while (false)
-
-#define TOSA_RETURN_ON_GRAPH_STATUS_ERROR(status)                                                                      \
-    do                                                                                                                 \
-    {                                                                                                                  \
-        if (status != GraphStatus::TOSA_VALID)                                                                         \
-        {                                                                                                              \
-            auto ustatus = static_cast<std::underlying_type_t<GraphStatus>>(status);                                   \
-            return static_cast<tosa_status_t>(ustatus);                                                                \
-        }                                                                                                              \
-    } while (false)
-
-namespace {
-
-tosa::DType translate_client_datatype(tosa_datatype_t type)
-{
-    switch (type)
-    {
-        case tosa_datatype_bf16_t:
-            return tosa::DType::DType_BF16;
-        case tosa_datatype_bool_t:
-            return tosa::DType::DType_BOOL;
-        case tosa_datatype_fp16_t:
-            return tosa::DType::DType_FP16;
-        case tosa_datatype_fp32_t:
-            return tosa::DType::DType_FP32;
-        case tosa_datatype_int16_t:
-            return tosa::DType::DType_INT16;
-        case tosa_datatype_int32_t:
-            return tosa::DType::DType_INT32;
-        case tosa_datatype_int48_t:
-            return tosa::DType::DType_INT48;
-        case tosa_datatype_int4_t:
-            return tosa::DType::DType_INT4;
-        case tosa_datatype_int8_t:
-            return tosa::DType::DType_INT8;
-        case tosa_datatype_uint16_t:
-            return tosa::DType::DType_UINT16;
-        case tosa_datatype_uint8_t:
-            return tosa::DType::DType_UINT8;
-        case tosa_datatype_shape_t:
-            return tosa::DType::DType_SHAPE;
-        default:
-            return tosa::DType::DType_UNKNOWN;
-    }
-};
-
-using TosaTensorInfo = std::pair<tosa::TosaSerializationTensor*, tosa_tensor_t*>;
-
-tosa::TosaSerializationTensor* translate_client_tensor(tosa_tensor_t& tensor, const std::string& name)
-{
-    std::vector<int32_t> shape(tensor.shape, tensor.shape + tensor.num_dims);
-    return new tosa::TosaSerializationTensor(name, shape, translate_client_datatype(tensor.data_type), {});
-}
-
-void addTensor(std::vector<TosaTensorInfo> &tensors, tosa_tensor_t& tensor, std::string tensorName) {
-    auto tensorDescr = translate_client_tensor(tensor, tensorName);
-    tensors.push_back(std::make_pair(tensorDescr, &tensor));
-}
-
-int setInputTensors(TosaReference::ModelRunnerImpl& runner, std::vector<TosaTensorInfo>& inputTensors)
-{
-    for (const auto& [tensorDescr, tensorData] : inputTensors)
-    {
-        auto status = runner.setInput(tensorDescr->GetName(), tensorData->data, tensorData->size);
-        TOSA_PROPAGATE_ERROR(status);
-    }
-
-    return 0;
-}
-
-int getOutputTensors(TosaReference::ModelRunnerImpl& runner, std::vector<TosaTensorInfo>& outputTensors)
-{
-    for (const auto& [tensorDescr, tensorData] : outputTensors)
-    {
-        auto status = runner.getOutput(tensorDescr->GetName(), tensorData->data, tensorData->size);
-        TOSA_PROPAGATE_ERROR(status);
-    }
-
-    return 0;
-}
-
-std::vector<std::string> getTensorNames(std::vector<TosaTensorInfo>& tensors)
-{
-    std::vector<std::string> tensorNames;
-    const auto mapping = [](const TosaTensorInfo &info){ return info.first->GetName(); };
-
-    std::transform(tensors.cbegin(), tensors.cend(), std::back_inserter(tensorNames), mapping);
-    return tensorNames;
-}
-
-std::vector<TosaSerializationTensor*> allTensors(std::vector<TosaTensorInfo> &inputTensors, std::vector<TosaTensorInfo> &outputTensors) {
-    std::vector<TosaSerializationTensor*> result;
-    const auto mapping = [](const TosaTensorInfo &info){ return info.first; };
-
-    std::transform(inputTensors.cbegin(), inputTensors.cend(), std::back_inserter(result), mapping);
-    std::transform(outputTensors.cbegin(), outputTensors.cend(), std::back_inserter(result), mapping);
-
-    return result;
-}
-
-tosa::ResizeMode translate_client_tosa_mode(tosa_mode_t mode) {
-    switch(mode) {
-        case tosa_mode_nearest:
-            return tosa::ResizeMode_NEAREST;
-        case tosa_mode_max:
-        case tosa_mode_bilinear:
-            return tosa::ResizeMode_BILINEAR;
-        default:
-            return tosa::ResizeMode_UNKNOWN;
-    }
-}
-
-tosa::DType translate_client_acc_size(tosa_acc_size_t acc_size) {
-    switch(acc_size) {
-        case tosa_acc_size_int32_t:
-            return tosa::DType::DType_INT32;
-        case tosa_acc_size_fp16_t:
-            return tosa::DType::DType_FP16;
-        case tosa_acc_size_fp32_t:
-            return tosa::DType::DType_FP32;
-        default:
-            return tosa::DType::DType_UNKNOWN;
-    }
-}
-
-}    // namespace
-
-extern "C"
-{
-    {% for operator in operators: %}
-    tosa_status_t tosa_run_{{ operator.name }} (
-        {%- for arg in operator.arguments: -%}
-            {% if arg.type != "tosa_tensor_t" -%}const {% endif -%}{{arg.type}} client_{{arg.name}}{{arg.shape}}
-            {% if not loop.last %},{% endif %}
-        {%- endfor -%},const func_ctx_t& func_ctx
-    )
-    {
-        // Create operator attributes
-        {% for att in operator.serialLibAtts: -%}
-            {{att.init}}
-        {%- endfor -%}
-
-        Tosa{{operator.serializeAttType}}Attribute attr
-        {%- if operator.serialLibAtts|length > 0 -%}
-        (
-            {%- for att in operator.serialLibAtts: -%}
-                {%- if att.init == "" -%}
-                    client_{{att.name}}
-                {%- else -%}
-                    {{att.name}}
-                {%- endif -%}
-                {% if not loop.last %}, {% endif %}
-            {%- endfor -%}
-        )
-        {%- endif -%};
-
-        // Create tensors
-        std::vector<TosaTensorInfo> inputTensors;
-        {% for input in operator.inputs: -%}
-            {%- if input.type == "tosa_tensor_list_t" -%}
-                for (int i = 0; i < client_{{input.name}}.size; i++) {
-                    addTensor(inputTensors, client_{{input.name}}.tensors[i], "{{input.name}}-" + std::to_string(i));
-                }
-            {%- else -%}
-                addTensor(inputTensors, client_{{input.name}}, "{{input.name}}");
-            {%- endif -%}
-        {%- endfor %}
-
-        std::vector<TosaTensorInfo> outputTensors;
-        {% for output in operator.outputs: -%}
-            addTensor(outputTensors, client_{{output}}, "{{output}}");
-        {%- endfor %}
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_{{operator.name|upper}},
-                                                      {%- if operator.serializeAttType != "None" -%}
-                                                        tosa::Attribute::Attribute_{{operator.serializeAttType}}Attribute
-                                                      {%- else -%}
-                                                        tosa::Attribute::Attribute_NONE
-                                                      {%- endif -%},
-                                                      &attr,
-                                                      getTensorNames(inputTensors),
-                                                      getTensorNames(outputTensors));
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("{{operator.name}}", "main", { op },
-                                                 allTensors(inputTensors, outputTensors),
-                                                 op->GetInputTensorNames(),
-                                                 op->GetOutputTensorNames());
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner(func_ctx.func_config, func_ctx.func_debug);
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-
-        TOSA_RETURN_ON_ERROR(setInputTensors(runner, inputTensors));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(getOutputTensors(runner, outputTensors));
-
-        return tosa_status_valid;
-    }
-    {% endfor %}
-
-}    // extern "C"
\ No newline at end of file
diff --git a/scripts/operator_api/templates/operators_h.j2 b/scripts/operator_api/templates/operators_h.j2
deleted file mode 100644
index 0c98da8..0000000
--- a/scripts/operator_api/templates/operators_h.j2
+++ /dev/null
@@ -1,51 +0,0 @@
-
-// Copyright (c) 2022-2023, ARM Limited.
-//
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//         http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
-
-// THIS FILE IS GENERATED. DO NOT EDIT!
-// See scripts/operator_api/generate_api.py
-
-#ifndef OPERATORS_H_
-#define OPERATORS_H_
-
-#include "func_config.h"
-#include "func_debug.h"
-#include "types.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-    struct func_ctx_t
-    {
-        func_config_t func_config = func_config_t{};
-        func_debug_t func_debug   = func_debug_t{};
-    };
-
-    {% for operator in operators: %}
-        tosa_status_t tosa_run_{{ operator.name }} (
-            {%- for arg in operator.arguments: -%}
-                {% if arg.type != "tosa_tensor_t" -%}const {% endif -%}{{arg.type}} client_{{arg.name}}{{arg.shape}}
-                {% if loop.index < operator.arguments|length %},{% endif %}
-            {%- endfor -%},const func_ctx_t& func_ctx);
-    {% endfor %}
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif // OPERATORS_H_
\ No newline at end of file