text: //------------------------------------------------------------------------------
  // GB_AxB_defs__min_rdiv_uint32: definitions for a single semiring
  //------------------------------------------------------------------------------
  
  // SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
  // SPDX-License-Identifier: Apache-2.0
  
  //------------------------------------------------------------------------------
  
  // If this file is in the Generated/ folder, do not edit it (auto-generated).
  
  #include "GB_dev.h"
  #ifndef GBCOMPACT
  #include "GB.h"
  #include "GB_control.h"
  #include "GB_bracket.h"
  #include "GB_sort.h"
  #include "GB_atomics.h"
  #include "GB_AxB_saxpy.h"
  #include "GB_AxB__include.h"
  #include "GB_unused.h"
  #include "GB_bitmap_assign_methods.h"
  #include "GB_ek_slice_search.c"
  
  // This C=A*B semiring is defined by the following types and operators:
  
  // A'*B (dot2):        GB (_Adot2B__min_rdiv_uint32)
  // A'*B (dot3):        GB (_Adot3B__min_rdiv_uint32)
  // C+=A'*B (dot4):     GB (_Adot4B__min_rdiv_uint32)
  // A*B (saxpy3):       GB (_Asaxpy3B__min_rdiv_uint32)
  //     no mask:        GB (_Asaxpy3B_noM__min_rdiv_uint32)
  //     mask M:         GB (_Asaxpy3B_M__min_rdiv_uint32)
  //     mask !M:        GB (_Asaxpy3B_notM__min_rdiv_uint32)
  // A*B (saxpy bitmap): GB (_AsaxbitB__min_rdiv_uint32)
  
  // C type:   uint32_t
  // A type:   uint32_t
  // B type:   uint32_t
  
  // Multiply: z = GB_IDIV_UNSIGNED (bkj, aik, 32)
  // Add:      if (cij > z) { cij = z ; }
  //           'any' monoid?  0
  //           atomic?        1
  //           OpenMP atomic? 0
  // MultAdd:  uint32_t x_op_y = GB_IDIV_UNSIGNED (bkj, aik, 32) ; cij = GB_IMIN (cij, x_op_y)
  // Identity: UINT32_MAX
  // Terminal: if (cij == 0) { break ; }
  
  #define GB_ATYPE \
      uint32_t
  
  #define GB_BTYPE \
      uint32_t
  
  #define GB_CTYPE \
      uint32_t
  
  #define GB_ASIZE (sizeof (GB_BTYPE))
  #define GB_BSIZE (sizeof (GB_BTYPE))
  #define GB_CSIZE (sizeof (GB_CTYPE))
  
  // true for int64, uint64, float, double, float complex, and double complex 
  #define GB_CTYPE_IGNORE_OVERFLOW \
      0
  
  // aik = Ax [pA]
  #define GB_GETA(aik,Ax,pA) \
      uint32_t aik = Ax [pA]
  
  // bkj = Bx [pB]
  #define GB_GETB(bkj,Bx,pB) \
      uint32_t bkj = Bx [pB]
  
  // Gx [pG] = Ax [pA]
  #define GB_LOADA(Gx,pG,Ax,pA) \
      Gx [pG] = Ax [pA]
  
  // Gx [pG] = Bx [pB]
  #define GB_LOADB(Gx,pG,Bx,pB) \
      Gx [pG] = Bx [pB]
  
  #define GB_CX(p) Cx [p]
  
  // multiply operator
  #define GB_MULT(z, x, y, i, k, j) \
      z = GB_IDIV_UNSIGNED (y, x, 32)
  
  // cast from a real scalar (or 2, if C is complex) to the type of C
  #define GB_CTYPE_CAST(x,y) \
      ((uint32_t) x)
  
  // cast from a real scalar (or 2, if A is complex) to the type of A
  #define GB_ATYPE_CAST(x,y) \
      ((uint32_t) x)
  
  // multiply-add
  #define GB_MULTADD(z, x, y, i, k, j) \
      uint32_t x_op_y = GB_IDIV_UNSIGNED (y, x, 32) ; z = GB_IMIN (z, x_op_y)
  
  // monoid identity value
  #define GB_IDENTITY \
      UINT32_MAX
  
  // 1 if the identity value can be assigned via memset, with all bytes the same
  #define GB_HAS_IDENTITY_BYTE \
      1
  
  // identity byte, for memset
  #define GB_IDENTITY_BYTE \
      0xFF
  
  // break if cij reaches the terminal value (dot product only)
  #define GB_DOT_TERMINAL(cij) \
      if (cij == 0) { break ; }
  
  // simd pragma for dot-product loop vectorization
  #define GB_PRAGMA_SIMD_DOT(cij) \
      ;
  
  // simd pragma for other loop vectorization
  #define GB_PRAGMA_SIMD_VECTORIZE GB_PRAGMA_SIMD
  
  // 1 for the PLUS_PAIR_(real) semirings, not for the complex case
  #define GB_IS_PLUS_PAIR_REAL_SEMIRING \
      0
  
  // declare the cij scalar
  #if GB_IS_PLUS_PAIR_REAL_SEMIRING
      // also initialize cij to zero
      #define GB_CIJ_DECLARE(cij) \
          uint32_t cij = 0
  #else
      // all other semirings: just declare cij, do not initialize it
      #define GB_CIJ_DECLARE(cij) \
          uint32_t cij
  #endif
  
  // cij = Cx [pC]
  #define GB_GETC(cij,p) cij = Cx [p]
  
  // Cx [pC] = cij
  #define GB_PUTC(cij,p) Cx [p] = cij
  
  // Cx [p] = t
  #define GB_CIJ_WRITE(p,t) Cx [p] = t
  
  // C(i,j) += t
  #define GB_CIJ_UPDATE(p,t) \
      if (Cx [p] > t) { Cx [p] = t ; }
  
  // x + y
  #define GB_ADD_FUNCTION(x,y) \
      GB_IMIN (x, y)
  
  // bit pattern for bool, 8-bit, 16-bit, and 32-bit integers
  #define GB_CTYPE_BITS \
      0xffffffffL
  
  // 1 if monoid update can skipped entirely (the ANY monoid)
  #define GB_IS_ANY_MONOID \
      0
  
  // 1 if monoid update is EQ
  #define GB_IS_EQ_MONOID \
      0
  
  // 1 if monoid update can be done atomically, 0 otherwise
  #define GB_HAS_ATOMIC \
      1
  
  // 1 if monoid update can be done with an OpenMP atomic update, 0 otherwise
  #if GB_MICROSOFT
      #define GB_HAS_OMP_ATOMIC \
          0
  #else
      #define GB_HAS_OMP_ATOMIC \
          0
  #endif
  
  // 1 for the ANY_PAIR semirings
  #define GB_IS_ANY_PAIR_SEMIRING \
      0
  
  // 1 if PAIR is the multiply operator 
  #define GB_IS_PAIR_MULTIPLIER \
      0
  
  // 1 if monoid is PLUS_FC32
  #define GB_IS_PLUS_FC32_MONOID \
      0
  
  // 1 if monoid is PLUS_FC64
  #define GB_IS_PLUS_FC64_MONOID \
      0
  
  // 1 if monoid is ANY_FC32
  #define GB_IS_ANY_FC32_MONOID \
      0
  
  // 1 if monoid is ANY_FC64
  #define GB_IS_ANY_FC64_MONOID \
      0
  
  // 1 if monoid is MIN for signed or unsigned integers
  #define GB_IS_IMIN_MONOID \
      1
  
  // 1 if monoid is MAX for signed or unsigned integers
  #define GB_IS_IMAX_MONOID \
      0
  
  // 1 if monoid is MIN for float or double
  #define GB_IS_FMIN_MONOID \
      0
  
  // 1 if monoid is MAX for float or double
  #define GB_IS_FMAX_MONOID \
      0
  
  // 1 for the FIRSTI or FIRSTI1 multiply operator
  #define GB_IS_FIRSTI_MULTIPLIER \
      0
  
  // 1 for the FIRSTJ or FIRSTJ1 multiply operator
  #define GB_IS_FIRSTJ_MULTIPLIER \
      0
  
  // 1 for the SECONDJ or SECONDJ1 multiply operator
  #define GB_IS_SECONDJ_MULTIPLIER \
      0
  
  // atomic compare-exchange
  #define GB_ATOMIC_COMPARE_EXCHANGE(target, expected, desired) \
      GB_ATOMIC_COMPARE_EXCHANGE_32 (target, expected, desired)
  
  #if GB_IS_ANY_PAIR_SEMIRING
  
      // result is purely symbolic; no numeric work to do.  Hx is not used.
      #define GB_HX_WRITE(i,t)
      #define GB_CIJ_GATHER(p,i)
      #define GB_CIJ_GATHER_UPDATE(p,i)
      #define GB_HX_UPDATE(i,t)
      #define GB_CIJ_MEMCPY(p,i,len)
  
  #else
  
      // Hx [i] = t
      #define GB_HX_WRITE(i,t) Hx [i] = t
  
      // Hx [i] = identity
      #define GB_HX_CLEAR(i) Hx [i] = GB_IDENTITY
  
      // Cx [p] = Hx [i]
      #define GB_CIJ_GATHER(p,i) Cx [p] = Hx [i]
  
      // Cx [p] += Hx [i]
      #define GB_CIJ_GATHER_UPDATE(p,i) \
          if (Cx [p] > Hx [i]) { Cx [p] = Hx [i] ; }
  
      // Hx [i] += t
      #define GB_HX_UPDATE(i,t) \
          if (Hx [i] > t) { Hx [i] = t ; }
  
      // memcpy (&(Cx [p]), &(Hx [i]), len)
      #define GB_CIJ_MEMCPY(p,i,len) \
          memcpy (Cx +(p), Hx +(i), (len) * sizeof(uint32_t))
  
  #endif
  
  // 1 if the semiring has a concise bitmap multiply-add
  #define GB_HAS_BITMAP_MULTADD \
      1
  
  // concise statement(s) for the bitmap case:
  //  if (exists)
  //      if (cb == 0)
  //          cx = ax * bx
  //          cb = 1
  //      else
  //          cx += ax * bx
  #define GB_BITMAP_MULTADD(cb,cx,exists,ax,bx) \
      uint32_t t = ((uint32_t) (GB_IDIV_UNSIGNED (bx, ax, 32))) ; if (exists && cx > t) { cx = t ; } ; cb |= exists
  
  // define X for bitmap multiply-add
  #define GB_XINIT \
      ;
  
  // load X [1] = bkj for bitmap multiply-add
  #define GB_XLOAD(bkj) \
      ;
  
  // disable this semiring and use the generic case if these conditions hold
  #define GB_DISABLE \
      (GxB_NO_MIN || GxB_NO_RDIV || GxB_NO_UINT32 || GxB_NO_MIN_UINT32 || GxB_NO_RDIV_UINT32 || GxB_NO_MIN_RDIV_UINT32)
  
  #endif
  
  