Add wasm tacle-bench targets

targets/wasm-tacle/kernel/minver/CMakeLists.txt

@@ -0,0 +1,25 @@
+# ~~~
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: 2026, Friedrich-Alexander-Universität Erlangen-Nürnberg (FAU)
+# ~~~
+
+cmake_minimum_required(VERSION 3.20)
+
+project(minver)
+
+set(TACLEBENCH_ROOT_PATH "${CMAKE_CURRENT_LIST_DIR}/../../..")
+set(REPOSITORY_ROOT_PATH "${CMAKE_CURRENT_LIST_DIR}/../../../..")
+
+set(APP_TARGET_NAME "${CMAKE_PROJECT_NAME}")
+
+if(DEFINED TACLEBENCH_VARIANT AND "${TACLEBENCH_VARIANT}" STREQUAL "inline")
+    set(APP_SOURCE_FILE_PATH 
+        "generated/modified_sources/inline/minver.c")
+else()
+    set(APP_SOURCE_FILE_PATH 
+        "generated/modified_sources/default/minver.c")
+endif()
+
+include(${REPOSITORY_ROOT_PATH}/cmake/taclebench_wasm.cmake)
+
+

targets/wasm-tacle/kernel/minver/ChangeLog.txt

@@ -0,0 +1,38 @@
+File: minver.c
+Original provenience: SNU-RT Benchmark Suite for Worst Case Timing Analysis
+
+2016-02-26:
+ - Added TACLeBench header to line 1
+ - Rename global variable a to minver_a
+ - Rename global variable b to minver_b
+ - Rename global variable c to minver_c
+ - Rename global variable aa to minver_aa
+ - Rename global variable a_i to minver_a_i
+ - Rename global variable e to minver_e
+ - Rename global variable det to minver_det
+ - Renamed function minver to minver_minver
+ - Renamed function mmul to minver_mmul
+ - Renamed function fabs to minver_fabs
+ - Renamed function main to minver_main
+ - Created new function main, calling minver_init, minver_main and
+   returning minver_return
+ - Reordered functions in source code: initialization- and
+   return-value-related functions first, followed by algorithm core
+   functions, followed by main functions
+ - Applied code formatting with astyle as in the example
+
+2016-03-09
+ - Removed static keyword from global minver_a array.
+
+2016-05-23
+ - Added addition of volatile to test data to avoid constant propagation
+ - Added check_sum and comparison with expected value
+
+2016-05-25
+ - Initialized variable r in function minver_minver()
+ - Removed parameter cols of minver_minver() function
+ - Renamed parameter rows of minver_minver() to side
+
+2017-07-04
+ - Removed self-assignment for WCC's flow-fact manager to avoid clangs
+   self-assign warning.

targets/wasm-tacle/kernel/minver/generated/modified_sources/default/minver.c

@@ -0,0 +1,253 @@
+/*
+
+    This program is part of the TACLeBench benchmark suite.
+    Version V 1.x
+
+    Name: minver
+
+    Author: Sung-Soo Lim
+
+    Function: Matrix inversion for 3x3 floating point matrix.
+
+    Source: SNU-RT Benchmark Suite, via MRTC
+           http://www.mrtc.mdh.se/projects/wcet/wcet_bench/minver/minver.c
+
+    Changes: a brief summary of major functional changes (not formatting)
+
+    License: may be used, modified, and re-distributed freely, but
+             the SNU-RT Benchmark Suite must be acknowledged
+
+*/
+
+/*
+    This program is derived from the SNU-RT Benchmark Suite for Worst
+    Case Timing Analysis by Sung-Soo Lim
+
+    Original source: Turbo C Programming for Engineering by Hyun Soo Ahn
+*/
+
+/*
+    Forward declaration of functions
+*/
+
+// Wasm loop bounds
+
+__attribute__((import_module("__pragma"), import_name("loopbound"))) extern void
+__pragma_loopbound(unsigned int min_bound, unsigned int max_bound);
+
+int minver_minver(int side, double eps);
+int minver_mmul(int row_a, int col_a, int row_b, int col_b);
+double minver_fabs(double n);
+void minver_init();
+int minver_return();
+__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
+minver_main();
+__attribute__((noinline)) __attribute__((export_name("main"))) int main(void);
+
+/*
+    Declaration of global variables
+*/
+
+double minver_a[3][3] = {
+    {3.0, -6.0, 7.0},
+    {9.0, 0.0, -5.0},
+    {5.0, -8.0, 6.0},
+};
+double minver_b[3][3];
+double minver_c[3][3];
+double minver_aa[3][3];
+double minver_a_i[3][3];
+double minver_det;
+
+/*
+    Arithmetic math functions
+*/
+
+double
+minver_fabs(double n) {
+    double f;
+
+    if (n >= 0)
+        f = n;
+    else
+        f = -n;
+    return f;
+}
+
+int
+minver_mmul(int row_a, int col_a, int row_b, int col_b) {
+    int i, j, k, row_c, col_c;
+    double w;
+
+    row_c = row_a;
+    col_c = col_b;
+
+    if (row_c < 1 || row_b < 1 || col_c < 1 || col_a != row_b)
+        return (999);
+
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < row_c; i++) {
+        __pragma_loopbound(3, 3);
+        for (j = 0; j < col_c; j++) {
+            w = 0.0;
+            __pragma_loopbound(3, 3);
+            for (k = 0; k < row_b; k++)
+                w += minver_a[i][k] * minver_b[k][j];
+
+            minver_c[i][j] = w;
+        }
+    }
+    return (0);
+}
+
+int
+minver_minver(int side, double eps) {
+
+    int work[500], i, j, k, iw;
+    int r = 0;
+    double w = 0, wmax, pivot, api, w1;
+
+    if (side < 2 || side > 500 || eps <= 0.0)
+        return (999);
+    w1 = 1.0;
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < side; i++)
+        work[i] = i;
+    __pragma_loopbound(3, 3);
+    for (k = 0; k < side; k++) {
+        wmax = 0.0;
+        __pragma_loopbound(1, 3);
+        for (i = k; i < side; i++) {
+            w = minver_fabs(minver_a[i][k]);
+            if (w > wmax) {
+                wmax = w;
+                r = i;
+            }
+        }
+        pivot = minver_a[r][k];
+        api = minver_fabs(pivot);
+        if (api <= eps) {
+            minver_det = w1;
+            return (1);
+        }
+        w1 *= pivot;
+        if (r != k) {
+            w1 = -w;
+            iw = work[k];
+            work[k] = work[r];
+            work[r] = iw;
+            __pragma_loopbound(3, 3);
+            for (j = 0; j < side; j++) {
+                w = minver_a[k][j];
+                minver_a[k][j] = minver_a[r][j];
+                minver_a[r][j] = w;
+            }
+        }
+        __pragma_loopbound(3, 3);
+        for (i = 0; i < side; i++)
+            minver_a[k][i] /= pivot;
+        __pragma_loopbound(3, 3);
+        for (i = 0; i < side; i++) {
+            if (i != k) {
+                w = minver_a[i][k];
+                if (w != 0.0) {
+                    __pragma_loopbound(3, 3);
+                    for (j = 0; j < side; j++) {
+                        if (j != k)
+                            minver_a[i][j] -= w * minver_a[k][j];
+                    }
+                    minver_a[i][k] = -w / pivot;
+                }
+            }
+        }
+        minver_a[k][k] = 1.0 / pivot;
+    }
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < side;) {
+        __pragma_loopbound(1, 3);
+        while (1) {
+            k = work[i];
+            if (k == i)
+                break;
+            iw = work[k];
+            work[k] = work[i];
+            work[i] = iw;
+            __pragma_loopbound(3, 3);
+            for (j = 0; j < side; j++) {
+                w = minver_a[k][i];
+                minver_a[k][i] = minver_a[k][k];
+                minver_a[k][k] = w;
+            }
+        }
+        i++;
+    }
+    minver_det = w1;
+    return (0);
+}
+
+/*
+    Initialization- and return-value-related functions
+*/
+
+void
+minver_init() {
+    int i, j;
+    volatile int x = 0;
+
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < 3; i++) {
+        __pragma_loopbound(3, 3);
+        for (j = 0; j < 3; j++)
+            minver_a[i][j] += x;
+    }
+}
+
+int
+minver_return() {
+    int i, j;
+    double check_sum = 0;
+
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < 3; i++) {
+        __pragma_loopbound(3, 3);
+        for (j = 0; j < 3; j++)
+            check_sum += minver_a_i[i][j];
+    }
+    /* Avoid double comparison */
+    return (int) (check_sum * 100) != 48;
+}
+
+/*
+    Main functions
+*/
+
+__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
+minver_main() {
+    int i, j;
+    double eps;
+    eps = 1.0e-6;
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < 3; i++) {
+        __pragma_loopbound(3, 3);
+        for (j = 0; j < 3; j++)
+            minver_aa[i][j] = minver_a[i][j];
+    }
+
+    minver_minver(3, eps);
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < 3; i++) {
+        __pragma_loopbound(3, 3);
+        for (j = 0; j < 3; j++)
+            minver_a_i[i][j] = minver_a[i][j];
+    }
+
+    minver_mmul(3, 3, 3, 3);
+}
+
+__attribute__((noinline)) __attribute__((export_name("main"))) int
+main(void) {
+    minver_init();
+    minver_main();
+
+    return (minver_return());
+}

targets/wasm-tacle/kernel/minver/generated/modified_sources/inline/minver.c

@@ -0,0 +1,263 @@
+/*
+
+    This program is part of the TACLeBench benchmark suite.
+    Version V 1.x
+
+    Name: minver
+
+    Author: Sung-Soo Lim
+
+    Function: Matrix inversion for 3x3 floating point matrix.
+
+    Source: SNU-RT Benchmark Suite, via MRTC
+           http://www.mrtc.mdh.se/projects/wcet/wcet_bench/minver/minver.c
+
+    Changes: a brief summary of major functional changes (not formatting)
+
+    License: may be used, modified, and re-distributed freely, but
+             the SNU-RT Benchmark Suite must be acknowledged
+
+*/
+
+/*
+    This program is derived from the SNU-RT Benchmark Suite for Worst
+    Case Timing Analysis by Sung-Soo Lim
+
+    Original source: Turbo C Programming for Engineering by Hyun Soo Ahn
+*/
+
+/*
+    Forward declaration of functions
+*/
+
+// Wasm loop bounds
+
+
+
+
+__attribute__((import_module("__pragma"), import_name("loopbound"))) extern void
+__pragma_loopbound(unsigned int min_bound, unsigned int max_bound);
+
+__attribute__((always_inline)) static inline int minver_minver(int side,
+                                                               double eps);
+__attribute__((always_inline)) static inline int
+minver_mmul(int row_a, int col_a, int row_b, int col_b);
+__attribute__((always_inline)) static inline double minver_fabs(double n);
+__attribute__((always_inline)) static inline void minver_init();
+__attribute__((always_inline)) static inline int minver_return();
+__attribute__((noinline)) __attribute__((export_name("entrypoint")))
+__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
+minver_main();
+__attribute__((noinline)) __attribute__((export_name("main")))
+__attribute__((noinline)) __attribute__((export_name("main"))) int
+main(void);
+
+/*
+    Declaration of global variables
+*/
+
+double minver_a[3][3] = {
+    {3.0, -6.0, 7.0},
+    {9.0, 0.0, -5.0},
+    {5.0, -8.0, 6.0},
+};
+double minver_b[3][3];
+double minver_c[3][3];
+double minver_aa[3][3];
+double minver_a_i[3][3];
+double minver_det;
+
+/*
+    Arithmetic math functions
+*/
+
+__attribute__((always_inline)) static inline double
+minver_fabs(double n) {
+    double f;
+
+    if (n >= 0)
+        f = n;
+    else
+        f = -n;
+    return f;
+}
+
+__attribute__((always_inline)) static inline int
+minver_mmul(int row_a, int col_a, int row_b, int col_b) {
+    int i, j, k, row_c, col_c;
+    double w;
+
+    row_c = row_a;
+    col_c = col_b;
+
+    if (row_c < 1 || row_b < 1 || col_c < 1 || col_a != row_b)
+        return (999);
+
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < row_c; i++) {
+        __pragma_loopbound(3, 3);
+        for (j = 0; j < col_c; j++) {
+            w = 0.0;
+            __pragma_loopbound(3, 3);
+            for (k = 0; k < row_b; k++)
+                w += minver_a[i][k] * minver_b[k][j];
+
+            minver_c[i][j] = w;
+        }
+    }
+    return (0);
+}
+
+__attribute__((always_inline)) static inline int
+minver_minver(int side, double eps) {
+
+    int work[500], i, j, k, iw;
+    int r = 0;
+    double w = 0, wmax, pivot, api, w1;
+
+    if (side < 2 || side > 500 || eps <= 0.0)
+        return (999);
+    w1 = 1.0;
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < side; i++)
+        work[i] = i;
+    __pragma_loopbound(3, 3);
+    for (k = 0; k < side; k++) {
+        wmax = 0.0;
+        __pragma_loopbound(1, 3);
+        for (i = k; i < side; i++) {
+            w = minver_fabs(minver_a[i][k]);
+            if (w > wmax) {
+                wmax = w;
+                r = i;
+            }
+        }
+        pivot = minver_a[r][k];
+        api = minver_fabs(pivot);
+        if (api <= eps) {
+            minver_det = w1;
+            return (1);
+        }
+        w1 *= pivot;
+        if (r != k) {
+            w1 = -w;
+            iw = work[k];
+            work[k] = work[r];
+            work[r] = iw;
+            __pragma_loopbound(3, 3);
+            for (j = 0; j < side; j++) {
+                w = minver_a[k][j];
+                minver_a[k][j] = minver_a[r][j];
+                minver_a[r][j] = w;
+            }
+        }
+        __pragma_loopbound(3, 3);
+        for (i = 0; i < side; i++)
+            minver_a[k][i] /= pivot;
+        __pragma_loopbound(3, 3);
+        for (i = 0; i < side; i++) {
+            if (i != k) {
+                w = minver_a[i][k];
+                if (w != 0.0) {
+                    __pragma_loopbound(3, 3);
+                    for (j = 0; j < side; j++) {
+                        if (j != k)
+                            minver_a[i][j] -= w * minver_a[k][j];
+                    }
+                    minver_a[i][k] = -w / pivot;
+                }
+            }
+        }
+        minver_a[k][k] = 1.0 / pivot;
+    }
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < side;) {
+        __pragma_loopbound(1, 3);
+        while (1) {
+            k = work[i];
+            if (k == i)
+                break;
+            iw = work[k];
+            work[k] = work[i];
+            work[i] = iw;
+            __pragma_loopbound(3, 3);
+            for (j = 0; j < side; j++) {
+                w = minver_a[k][i];
+                minver_a[k][i] = minver_a[k][k];
+                minver_a[k][k] = w;
+            }
+        }
+        i++;
+    }
+    minver_det = w1;
+    return (0);
+}
+
+/*
+    Initialization- and return-value-related functions
+*/
+
+__attribute__((always_inline)) static inline void
+minver_init() {
+    int i, j;
+    volatile int x = 0;
+
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < 3; i++) {
+        __pragma_loopbound(3, 3);
+        for (j = 0; j < 3; j++)
+            minver_a[i][j] += x;
+    }
+}
+
+__attribute__((always_inline)) static inline int
+minver_return() {
+    int i, j;
+    double check_sum = 0;
+
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < 3; i++) {
+        __pragma_loopbound(3, 3);
+        for (j = 0; j < 3; j++)
+            check_sum += minver_a_i[i][j];
+    }
+    /* Avoid double comparison */
+    return (int) (check_sum * 100) != 48;
+}
+
+/*
+    Main functions
+*/
+
+__attribute__((noinline)) __attribute__((export_name("entrypoint")))
+__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
+minver_main() {
+    int i, j;
+    double eps;
+    eps = 1.0e-6;
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < 3; i++) {
+        __pragma_loopbound(3, 3);
+        for (j = 0; j < 3; j++)
+            minver_aa[i][j] = minver_a[i][j];
+    }
+
+    minver_minver(3, eps);
+    __pragma_loopbound(3, 3);
+    for (i = 0; i < 3; i++) {
+        __pragma_loopbound(3, 3);
+        for (j = 0; j < 3; j++)
+            minver_a_i[i][j] = minver_a[i][j];
+    }
+
+    minver_mmul(3, 3, 3, 3);
+}
+
+__attribute__((noinline)) __attribute__((export_name("main")))
+__attribute__((noinline)) __attribute__((export_name("main"))) int
+main(void) {
+    minver_init();
+    minver_main();
+
+    return (minver_return());
+}

targets/wasm-tacle/kernel/minver/minver.c

@@ -0,0 +1,261 @@
+/*
+
+    This program is part of the TACLeBench benchmark suite.
+    Version V 1.x
+
+    Name: minver
+
+    Author: Sung-Soo Lim
+
+    Function: Matrix inversion for 3x3 floating point matrix.
+
+    Source: SNU-RT Benchmark Suite, via MRTC
+           http://www.mrtc.mdh.se/projects/wcet/wcet_bench/minver/minver.c
+
+    Changes: a brief summary of major functional changes (not formatting)
+
+    License: may be used, modified, and re-distributed freely, but
+             the SNU-RT Benchmark Suite must be acknowledged
+
+*/
+
+/*
+    This program is derived from the SNU-RT Benchmark Suite for Worst
+    Case Timing Analysis by Sung-Soo Lim
+
+    Original source: Turbo C Programming for Engineering by Hyun Soo Ahn
+*/
+
+/*
+    Forward declaration of functions
+*/
+
+int minver_minver( int side, double eps );
+int minver_mmul( int row_a, int col_a, int row_b, int col_b );
+double minver_fabs( double n );
+void minver_init();
+int minver_return();
+void minver_main();
+int main( void );
+
+/*
+    Declaration of global variables
+*/
+
+double  minver_a[ 3 ][ 3 ] = {
+  {3.0, -6.0,  7.0},
+  {9.0,  0.0, -5.0},
+  {5.0, -8.0,  6.0},
+};
+double minver_b[ 3 ][ 3 ];
+double minver_c[ 3 ][ 3 ];
+double minver_aa[ 3 ][ 3 ];
+double minver_a_i[ 3 ][ 3 ];
+double minver_det;
+
+/*
+    Arithmetic math functions
+*/
+
+
+double minver_fabs( double n )
+{
+  double f;
+
+  if ( n >= 0 )
+    f = n;
+  else
+    f = -n;
+  return f;
+}
+
+
+int  minver_mmul( int row_a, int col_a, int row_b, int col_b )
+{
+  int i, j, k, row_c, col_c;
+  double w;
+
+  row_c = row_a;
+  col_c = col_b;
+
+  if ( row_c < 1 || row_b < 1 || col_c < 1 || col_a != row_b )
+    return ( 999 );
+
+  _Pragma( "loopbound min 3 max 3" )
+  for ( i = 0; i < row_c; i++ ) {
+    _Pragma( "loopbound min 3 max 3" )
+    for ( j = 0; j < col_c; j++ ) {
+      w = 0.0;
+      _Pragma( "loopbound min 3 max 3" )
+      for ( k = 0; k < row_b; k++ )
+        w += minver_a[ i ][ k ] * minver_b[ k ][ j ];
+
+      minver_c[ i ][ j ] = w;
+
+    }
+  }
+  return ( 0 );
+
+}
+
+
+int minver_minver( int side, double eps )
+{
+
+  int work[ 500 ], i, j, k, iw;
+  int r = 0;
+  double w = 0, wmax, pivot, api, w1;
+
+  if ( side < 2 || side > 500 || eps <= 0.0 )
+    return ( 999 );
+  w1 = 1.0;
+  _Pragma( "loopbound min 3 max 3" )
+  for ( i = 0; i < side; i++ )
+    work[ i ] = i;
+  _Pragma( "loopbound min 3 max 3" )
+  for ( k = 0; k < side; k++ ) {
+    wmax = 0.0;
+    _Pragma( "loopbound min 1 max 3" )
+    for ( i = k; i < side; i++ ) {
+      w = minver_fabs( minver_a[ i ][ k ] );
+      if ( w > wmax ) {
+        wmax = w;
+        r = i;
+      }
+    }
+    pivot = minver_a[ r ][ k ];
+    api = minver_fabs( pivot );
+    if ( api <= eps ) {
+      minver_det = w1;
+      return ( 1 );
+    }
+    w1 *= pivot;
+    if ( r != k ) {
+      w1 = -w;
+      iw = work[ k ];
+      work[ k ] = work[ r ];
+      work[ r ] = iw;
+      _Pragma( "loopbound min 3 max 3" )
+      for ( j = 0; j < side; j++ ) {
+        w = minver_a[ k ][ j ];
+        minver_a[ k ][ j ] = minver_a[ r ][ j ];
+        minver_a[ r ][ j ] = w;
+      }
+    }
+    _Pragma( "loopbound min 3 max 3" )
+    for ( i = 0; i < side; i++ )
+      minver_a[ k ][ i ] /= pivot;
+    _Pragma( "loopbound min 3 max 3" )
+    for ( i = 0; i < side; i++ ) {
+      if ( i != k ) {
+        w = minver_a[ i ][ k ];
+        if ( w != 0.0 ) {
+          _Pragma( "loopbound min 3 max 3" )
+          for ( j = 0; j < side; j++ ) {
+            if ( j != k ) minver_a[ i ][ j ] -= w * minver_a[ k ][ j ];
+          }
+          minver_a[ i ][ k ] = -w / pivot;
+
+        }
+      }
+    }
+    minver_a[ k ][ k ] = 1.0 / pivot;
+  }
+  _Pragma( "loopbound min 3 max 3" )
+  for ( i = 0; i < side; ) {
+    _Pragma( "loopbound min 1 max 3" )
+    while ( 1 ) {
+      k = work[ i ];
+      if ( k == i ) break;
+      iw = work[ k ];
+      work[ k ] = work[ i ];
+      work[ i ] = iw;
+      _Pragma( "loopbound min 3 max 3" )
+      for ( j = 0; j < side; j++ ) {
+        w = minver_a [k ][ i ];
+        minver_a[ k ][ i ] = minver_a[ k ][ k ];
+        minver_a[ k ][ k ] = w;
+      }
+    }
+    i++;
+  }
+  minver_det = w1;
+  return ( 0 );
+
+}
+
+/*
+    Initialization- and return-value-related functions
+*/
+
+void minver_init()
+{
+  int i, j;
+  volatile int x = 0;
+
+  _Pragma( "loopbound min 3 max 3" )
+  for ( i = 0; i < 3; i++ ) {
+    _Pragma( "loopbound min 3 max 3" )
+    for ( j = 0; j < 3; j++ )
+      minver_a[ i ][ j ] += x;
+  }
+}
+
+
+int minver_return()
+{
+  int i, j;
+  double check_sum = 0;
+
+  _Pragma( "loopbound min 3 max 3" )
+  for ( i = 0; i < 3; i++ ) {
+    _Pragma( "loopbound min 3 max 3" )
+    for ( j = 0; j < 3; j++ )
+      check_sum += minver_a_i[ i ][ j ];
+  }
+  /* Avoid double comparison */
+  return ( int )( check_sum * 100 ) != 48;
+}
+
+
+/*
+    Main functions
+*/
+
+
+void _Pragma( "entrypoint" ) minver_main()
+{
+  int i, j;
+  double eps;
+  eps = 1.0e-6;
+  _Pragma( "loopbound min 3 max 3" )
+  for ( i = 0; i < 3; i++ ) {
+    _Pragma( "loopbound min 3 max 3" )
+    for ( j = 0; j < 3; j++ )
+      minver_aa[ i ][ j ] = minver_a[ i ][ j ];
+  }
+
+  minver_minver( 3, eps );
+  _Pragma( "loopbound min 3 max 3" )
+  for ( i = 0; i < 3; i++ ) {
+    _Pragma( "loopbound min 3 max 3" )
+    for ( j = 0; j < 3; j++ )
+      minver_a_i[ i ][ j ] = minver_a[ i ][ j ];
+  }
+
+  minver_mmul( 3, 3, 3, 3 );
+}
+
+
+int main( void )
+{
+  minver_init();
+  minver_main();
+
+  return ( minver_return() );
+}
+
+
+
+
+