text: //------------------------------------------------------------------------------
  // GB_red:  hard-coded functions for reductions
  //------------------------------------------------------------------------------
  
  // SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
  // SPDX-License-Identifier: Apache-2.0
  
  //------------------------------------------------------------------------------
  
  // If this file is in the Generated2/ folder, do not edit it
  // (it is auto-generated from Generator/*).
  
  #include "GB.h"
  #ifndef GBCOMPACT
  #include "GB_atomics.h"
  #include "GB_control.h" 
  #include "GB_red__include.h"
  
  // The reduction is defined by the following types and operators:
  
  // Assemble tuples:    GB (_red_build__times_fp32)
  // Reduce to scalar:   GB (_red_scalar__times_fp32)
  
  // A type:   float
  // C type:   float
  
  // Reduce:   s *= aij
  // Identity: 1
  // Terminal: ;
  
  #define GB_ATYPE \
      float
  
  #define GB_CTYPE \
      float
  
  // monoid identity value
  
      #define GB_IDENTITY \
          1
  
  // declare a scalar and set it equal to the monoid identity value
  
      #define GB_SCALAR_IDENTITY(s)                   \
          float s = GB_IDENTITY
  
  // Array to array
  
      // W [k] = (ztype) S [i], with typecast
      #define GB_CAST_ARRAY_TO_ARRAY(W,k,S,i)         \
          W [k] = S [i]
  
      // W [k] += (ztype) S [i], with typecast
      #define GB_ADD_CAST_ARRAY_TO_ARRAY(W,k,S,i)     \
          W [k] *= S [i]
  
      // W [k] += Ax [p], no typecast
      #define GB_ADD_ARRAY_TO_ARRAY(W,k,Ax,p)         \
          W [k] *= Ax [p]  
  
  // Array to scalar
  
      // s += (ztype) Ax [p], with typecast
      #define GB_ADD_CAST_ARRAY_TO_SCALAR(s,Ax,p)     \
          s *= Ax [p]
  
      // s += S [i], no typecast
      #define GB_ADD_ARRAY_TO_SCALAR(s,S,i)           \
          s *= S [i]
  
  // Scalar to array
  
      // W [k] = s, no typecast
      #define GB_COPY_SCALAR_TO_ARRAY(W,k,s)          \
          W [k] = s
  
  // break the loop if terminal condition reached
  
      #define GB_HAS_TERMINAL                         \
          0
  
      #define GB_IS_TERMINAL(s)                       \
          (none)
  
      #define GB_TERMINAL_VALUE                       \
          (none)
  
  // panel size for built-in operators
  
      #define GB_PANEL                                \
          64
  
  // special case for the ANY monoid
  
      #define GB_IS_ANY_MONOID                        \
          0
  
  // disable this operator and use the generic case if these conditions hold
  #define GB_DISABLE \
      (GxB_NO_TIMES || GxB_NO_FP32 || GxB_NO_TIMES_FP32)
  
  //------------------------------------------------------------------------------
  // reduce to a non-iso matrix to scalar, for monoids only
  //------------------------------------------------------------------------------
  
  
  GrB_Info GB (_red_scalar__times_fp32)
  (
      float *result,
      const GrB_Matrix A,
      GB_void *restrict W_space,
      bool *restrict F,
      int ntasks,
      int nthreads
  )
  { 
      #if GB_DISABLE
      return (GrB_NO_VALUE) ;
      #else
      float s = (*result) ;
      float *restrict W = (float *) W_space ;
      if (A->nzombies > 0 || GB_IS_BITMAP (A))
      {
          #include "GB_reduce_to_scalar_template.c"
      }
      else
      {
          #include "GB_reduce_panel.c"
      }
      (*result) = s ;
      return (GrB_SUCCESS) ;
      #endif
  }
  
  
  //------------------------------------------------------------------------------
  // build a non-iso matrix
  //------------------------------------------------------------------------------
  
  GrB_Info GB (_red_build__times_fp32)
  (
      float *restrict Tx,
      int64_t  *restrict Ti,
      const float *restrict Sx,
      int64_t nvals,
      int64_t ndupl,
      const int64_t *restrict I_work,
      const int64_t *restrict K_work,
      const int64_t *restrict tstart_slice,
      const int64_t *restrict tnz_slice,
      int nthreads
  )
  { 
      #if GB_DISABLE
      return (GrB_NO_VALUE) ;
      #else
      #include "GB_reduce_build_template.c"
      return (GrB_SUCCESS) ;
      #endif
  }
  
  #endif
  
  