text: //------------------------------------------------------------------------------
  // GB_binop:  hard-coded functions for each built-in binary operator
  //------------------------------------------------------------------------------
  
  // SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
  // http://suitesparse.com   See GraphBLAS/Doc/License.txt for license.
  
  //------------------------------------------------------------------------------
  
  // If this file is in the Generated/ folder, do not edit it (auto-generated).
  
  #include "GB.h"
  #ifndef GBCOMPACT
  #include "GB_control.h"
  #include "GB_ek_slice.h"
  #include "GB_binop__include.h"
  
  // C=binop(A,B) is defined by the following types and operators:
  
  // A+B function (eWiseAdd):    GB_AaddB__second_int32
  // A.*B function (eWiseMult):  GB_AemultB__second_int32
  // A*D function (colscale):    GB_AxD__second_int32
  // D*A function (rowscale):    GB_DxB__second_int32
  
  // C type:   int32_t
  // A type:   int32_t
  // B type:   int32_t
  // BinaryOp: cij = bij
  
  #define GB_ATYPE \
      int32_t
  
  #define GB_BTYPE \
      int32_t
  
  #define GB_CTYPE \
      int32_t
  
  // aij = Ax [pA]
  #define GB_GETA(aij,Ax,pA)  \
      ;
  
  // bij = Bx [pB]
  #define GB_GETB(bij,Bx,pB)  \
      int32_t bij = Bx [pB]
  
  // cij = Ax [pA]
  #define GB_COPY_A_TO_C(cij,Ax,pA) cij = Ax [pA] ;
  
  // cij = Bx [pB]
  #define GB_COPY_B_TO_C(cij,Bx,pB) cij = Bx [pB] ;
  
  #define GB_CX(p) Cx [p]
  
  // binary operator
  #define GB_BINOP(z, x, y)   \
      z = y ;
  
  // do the numerical phases of GB_add and GB_emult
  #define GB_PHASE_2_OF_2
  
  // hard-coded loops can be vectorized
  #define GB_PRAGMA_VECTORIZE GB_PRAGMA_SIMD
  
  // disable this operator and use the generic case if these conditions hold
  #define GB_DISABLE \
      (GxB_NO_SECOND || GxB_NO_INT32 || GxB_NO_SECOND_INT32)
  
  //------------------------------------------------------------------------------
  // C = A*D, column scale with diagonal D matrix
  //------------------------------------------------------------------------------
  
  GrB_Info GB_AxD__second_int32
  (
      GrB_Matrix C,
      const GrB_Matrix A, bool A_is_pattern,
      const GrB_Matrix D, bool D_is_pattern,
      const int64_t *restrict kfirst_slice,
      const int64_t *restrict klast_slice,
      const int64_t *restrict pstart_slice,
      const int ntasks,
      const int nthreads
  )
  { 
      #if GB_DISABLE
      return (GrB_NO_VALUE) ;
      #else
      int32_t *restrict Cx = C->x ;
      #include "GB_AxB_colscale_meta.c"
      return (GrB_SUCCESS) ;
      #endif
  }
  
  //------------------------------------------------------------------------------
  // C = D*B, row scale with diagonal D matrix
  //------------------------------------------------------------------------------
  
  GrB_Info GB_DxB__second_int32
  (
      GrB_Matrix C,
      const GrB_Matrix D, bool D_is_pattern,
      const GrB_Matrix B, bool B_is_pattern,
      int nthreads
  )
  { 
      #if GB_DISABLE
      return (GrB_NO_VALUE) ;
      #else
      int32_t *restrict Cx = C->x ;
      #include "GB_AxB_rowscale_meta.c"
      return (GrB_SUCCESS) ;
      #endif
  }
  
  //------------------------------------------------------------------------------
  // eWiseAdd: C = A+B or C<M> = A+B
  //------------------------------------------------------------------------------
  
  GrB_Info GB_AaddB__second_int32
  (
      GrB_Matrix C,
      const GrB_Matrix M,
      const GrB_Matrix A,
      const GrB_Matrix B,
      const bool Ch_is_Mh,
      const int64_t *restrict C_to_M,
      const int64_t *restrict C_to_A,
      const int64_t *restrict C_to_B,
      const GB_task_struct *restrict TaskList,
      const int ntasks,
      const int nthreads
  )
  { 
      #if GB_DISABLE
      return (GrB_NO_VALUE) ;
      #else
      #include "GB_add_template.c"
      return (GrB_SUCCESS) ;
      #endif
  }
  
  //------------------------------------------------------------------------------
  // eWiseMult: C = A.*B or C<M> = A.*B
  //------------------------------------------------------------------------------
  
  GrB_Info GB_AemultB__second_int32
  (
      GrB_Matrix C,
      const GrB_Matrix M,
      const GrB_Matrix A,
      const GrB_Matrix B,
      const int64_t *restrict C_to_M,
      const int64_t *restrict C_to_A,
      const int64_t *restrict C_to_B,
      const GB_task_struct *restrict TaskList,
      const int ntasks,
      const int nthreads
  )
  { 
      #if GB_DISABLE
      return (GrB_NO_VALUE) ;
      #else
      #include "GB_emult_template.c"
      return (GrB_SUCCESS) ;
      #endif
  }
  
  #endif
  
  